--- /dev/null
+Martin Schulze <mschulze@cvs.gnome.org>
+Murray Cumming <murrayc@murrayc.com>
+Cedric Gustin <cedric.gustin@swing.be> (win32 support)
+Timothy M. Shead <tshead@k-3d.com> and James Lin <jameslin@vmware.com> (MSVC support)
+Damien Carbery <Damien.Carbery@Sun.COM> (Sun FORTE C++ support)
+Takashi Takekawa <takekawa@users.sourceforge.jp> (Intel C++ support)
+Andreas Rottmann <rottmann@users.sourceforge.net> (make system)
+Karl Einar Nelson <kenelson@ece.ucdavis.edu> (initial version 1.9.4)
--- /dev/null
+
+ 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
+ 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.
+\f
+ 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.
+
+
+ <one line to give the library's name and a brief idea of what it
+does.>
+ Copyright (C) <year> <name of author>
+
+ 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.
+
+ <signature of Ty Coon>, 1 April 1990
+ Ty Coon, President of Vice
+
+That's all there is to it!
+
+
--- /dev/null
+2022-02-11 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ 2.10.8
+
+2022-02-11 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ meson.build: Specify 'check' option in run_command()
+
+ The default value will be changed in future Meson releases.
+
+ Don't use deprecated python3.path() and execute(..., gui_app: ...).
+
+2022-02-11 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ docs/reference/Doxyfile.in: Remove obsolete entry
+
+2022-01-31 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ tools/tutorial-custom-cmd.py: Add comment about used stylesheet
+
+2021-12-12 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ Revert "sigc++.h: Don't mention CMake"
+
+ This reverts commit 53551050c59c3a35e64816f78e555ee2e064cc31.
+ sigc++-2.0 can be used by a CMake project even though
+ sigc++-2.0 itself has not been built with CMake.
+
+2021-12-11 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ sigc++.h: Don't mention CMake
+
+ There is no CMake support in sigc++-2.0.
+
+2021-11-09 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ NMake Makefiles: Allow building with VS2022
+
+ Add checks to distnguish between VS2019 and VS2022.
+
+2021-09-27 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ docs/manual, Meson config: Check if xmllint can be used
+
+2021-09-20 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ docs/manual: Upgrade from DocBook 4.1 to DocBook 5.0
+
+2021-08-17 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ meson.build: Check if Perl is required for building documentation
+
+ New versions of mm-common use the Python scripts doc_postprocess.py
+ and doc_install.py instead of the Perl scripts doc-postprocess.pl and
+ doc-install.pl when documentation is built.
+
+2021-07-04 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ docs: Remove some obsolete files
+
+ Remove docs/manual/README and docs/reference/README.
+
+2021-07-04 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ docs/manual: Add some formatting when html files are generated
+
+ making it slightly more similar to gtkmm-documentation and libxml++.
+ In Autotools builds, don't distribute the empty manual/README file.
+
+2021-07-04 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ docs/manual/libsigc_manual.xml: Add id on <sect1> elements
+
+2021-05-20 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ 2.10.7
+
+2021-05-19 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ Documentation: Let links point to sigc++2 and gtkmm3 versions
+
+2021-05-18 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ Visual Studio build files: Some cleanups
+
+ Replace /wd4530 with /EHsc, as that is the more proper CXXFlag to use for
+ Visual Studio builds for C++ projects.
+
+2021-05-18 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ Add dependencies to Doxygen tag files in subprojects
+
+ Doxygen in a main project shall not be called before tag files have been
+ created or updated in subprojects.
+
+2021-05-14 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ Fix build as subproject without building documentation
+
+ * meson.build: If mm-common-get is not found in maintainer-mode
+ with 'required: false', try with 'required: true'.
+ Don't try to use tag_file, if documentation is not built.
+ * docs/reference/meson.build: Don't use variables from modules
+ that don't define doxytagfile. These are subprojects that don't build
+ their documentation.
+
+ Fixes #71
+
+2021-05-05 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ Subprojects can use meson.add_dist_script() if meson.version() >= 0.58.0
+
+ * meson.build:
+ * MSVC_NMake/meson.build:
+ * docs/manual/meson.build:
+ * docs/reference/meson.build:
+ * sigc++/meson.build:
+ Call add_dist_script() in a subproject, if meson.version() >= 0.58.0.
+ * tools/handle-built-files.py:
+ * tools/tutorial-custom-cmd.py:
+ Use MESON_PROJECT_DIST_ROOT if it exists, else MESON_DIST_ROOT.
+ It exists if meson.version() >= 0.58.0.
+
+2021-05-04 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ Meson build: Make quiet installations possible
+
+ * tools/handle-built-files.py: Don't print names of installed files if
+ environment variable MESON_INSTALL_QUIET is set.
+ It is set by "meson install --quiet" in Meson 0.54.0 and newer.
+
+2021-04-07 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ Meson build: No implicit_include_directories
+
+2021-03-31 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ Meson build: Fix dependency on generated files
+
+ Add meson.build files in all subdirectories of sigc++/ where .h and/or .cc
+ files are generated. Looks like it's necessary in order to have all
+ dependent .cc files recompiled when a .h.m4 file has been changed.
+ Don't know if it has always been necessary, or if it has become necessary
+ due to changes in Meson and/or Ninja.
+
+2021-03-26 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ Meson build: Make it possible to use sigc++ as a subproject
+
+ mm-common can be a subproject of sigc++.
+
+2021-03-26 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ docs/reference/Doxyfile.in: Remove obsolete entries
+
+2020-11-25 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ 2.10.6
+
+2020-10-12 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ sigc++/sigc++.h: Fix a typo
+
+2020-10-12 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ sigc++/sigc++.h: Describe how to use libsigc++ with meson
+
+2020-10-04 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ Docs: Change libsigc++ webpage mentions to GitHub
+
+ Change libsigc.sourceforge.net to
+ libsigcplusplus.github.io/libsigcplusplus.
+
+2020-09-28 Tom Schoonjans <Tom.Schoonjans@rfi.ac.uk>
+
+ Meson build: fix versioning on macOS
+
+2020-09-27 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ 2.10.4
+
+2020-07-23 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ NMake Makefiles: Use Meson-style DLL and .lib naming if requested
+
+ To make things more consistent and less prone to confusion, if 'USE_MESON_LIBS'
+ is specified in the NMake command line, build the DLLs and .lib's that are
+ named like the Meson counterparts. Binaries built with Meson+Visual Studio
+ and the ones that are built via NMake using 'USE_MESON_LIBS' are
+ interchangeable.
+
+2020-07-22 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ NMake Makefiles: Fix building from Meson-built tarballs
+
+ We need to look for sigc++config.h in $(srcroot)\untracked\MSVC_NMake also, and
+ make sure that we do not generate sources unnecessarily.
+
+ Also streamline the source generating process into the 'all' target, so there
+ is no more need to run the 'prep-git-build' target.
+
+2020-07-08 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ NMake Makefiles: Support ARM64 Windows builds
+
+ This will make the NMake Makefiles capable of building ARM64 binaries of libsigc++,
+ which can be used on Windows 10 on ARM systems.
+
+2020-06-29 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ docs/reference/: Update for Doxygen >= 1.8.16
+
+ * docs/reference/meson.build: Doxygen 1.8.16 and later does not store
+ tag file names in the html files. This requires changes in meson.build
+ and in doc-install.pl (in mm-common). Otherwise references to other modules
+ won't be updated in the html files when they are installed.
+ * docs/reference/Doxyfile.in: Remove PERL_PATH and MSCGEN_PATH.
+ Doxygen since version 1.8.0 does not use them.
+
+2020-06-27 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ docs/manual/libsigc_manual.xml: Update signal and slot syntax
+
+ Update the syntax of template parameters.
+ sigc::signal<void,int> -> sigc::signal<void(int)>. The old syntax is
+ deprecated.
+
+ Mention lambda expressions.
+
+ Although sigc::retype() is a template function, no template parameters
+ shall be specified when it's called.
+
+ See #59
+
+2020-06-18 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ Re-work the NMake Makefiles
+
+ Do some cleanups, to improve maintainability and running speed, where:
+
+ * Change instances of 'libsigcpp' to 'sigc'
+ * "Generate" the build rules for the test and example programs, instead
+ of hand-writing them, since they use largely similar rules.
+ * Don't use separate rules to create intermediate directories, so that
+ we do not need to re-load the Makefiles unnecessarily
+
+2020-06-18 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ NMake Makefiles: Add rules to generate sources
+
+ This adds rules to use m4 to generate the headers and sources from their .m4
+ counterparts, which allows building directly from a GIT checkout, after
+ running the 'prep-git-build' target.
+
+ Update the README.txt file to reflect on this enhancement, and make sure the
+ generated headers are also copied when running the 'install' target
+
+2020-06-18 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ NMake Makefiles: Add rules to generate sigc.rc and sigc++config.h
+
+ This adds a 'prep-git-build' target which is run before building any of the
+ other targets so that this paves the first steps in making the libsigc++-2-10
+ branch buildable directly from a GIT checkout with the NMake Makefiles.
+
+ Note that unlike the master (3.x) branch, we still need to use m4 to generate
+ some sources and headers, which will be covered in the following commit.
+
+2020-06-18 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ NMake Makefiles: Support Visual Studio 2019 better
+
+ Make Visual Studio 2019 builds distinct from 2017 builds. Note that for the
+ libsigc++-2-10 branch, we do not distinguish between Visual Studio 2015, 2017
+ and 2019 in regards to the built DLL and .lib filenames, since they are
+ found to be interchangeable.
+
+2020-06-18 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ NMake Makefiles: Use 'md' instead of 'mkdir'
+
+ This is to avoid confusion if we have the UNIX 'mkdir' command in our PATH, such as
+ when Cygwin is installed and used.
+
+2020-04-02 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ Meson build: Set default value of the 'warnings' option to 'min'
+
+ * MSVC_NMake/meson.build: Copy sigc++config.h with configure_file().
+ * Makefile.am: Remove tools/dist-cmd.py.
+ * docs/manual/meson.build:
+ * docs/reference/meson.build: Don't use tools/dist-cmd.py.
+ * sigc++/meson.build: Don't use tools/dist-cmd.py.
+ * meson.build: Use dist-warnings when a tarball is tested by
+ 'ninja dist' or 'meson dist'. Check if doc-reference.py exists, if not
+ maintainer-mode. Add a better error message if mm-common-get is required
+ but not found.
+ * meson_options.txt: Set default value of the 'warnings' to 'min'.
+ Add 'dist-warnings' with default value 'fatal'.
+ * tools/dist-cmd.py: Removed file. It's not necessary in add_dist_script()
+ when the first parameter is python3.path().
+
+2020-03-25 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ 2.10.3
+
+2020-03-24 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ README: Describe building with Meson and Autotools
+
+ and remove the description of the directory structure,
+ which is not very useful.
+
+2020-03-10 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ examples: Disable deprecated API when building with Meson
+
+ Deprecated SIGCXX API is disabled when example programs are built
+ with Autotools. Do the same when building with Meson.
+
+2020-01-13 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ README: Describe building with Meson
+
+2020-01-02 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ docs/reference/meson.build: Check if perl is found
+
+ Don't use perl.path() when configuring Doxyfile, if perl is not found.
+ Perl is not required, if build-documentation=false.
+ Fixes #53
+
+2019-12-30 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ meson.build: Change project name, sigc++ -> libsigc++
+
+ Autotools make tarballs called libsigc++-x.y.z.tar.xz. No reason to
+ change that. The leading "lib" is now also restored in some locations
+ in the reference documentation.
+
+2019-12-30 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ Update untracked/README
+
+2019-12-29 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ meson.build: Check if .git is a directory or a file
+
+ In a git worktree, .git is a regular file.
+
+ See https://gitlab.gnome.org/GNOME/pangomm/merge_requests/8
+
+2019-12-29 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ sigc++/meson.build: Library name is sigc-2.0
+
+ Pointed out by Chun-wei Fan in PR #51.
+
+2019-12-29 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ NMake Makefiles: Separate outdir by toolset version
+
+ This is to reduce the likelihood of accidently mixing DLLs that are
+ linked with different CRTs in the build tree.
+
+ Also clean up rules a bit.
+
+2019-12-29 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ build: Support NMake builds from Meson tarballs
+
+ This adds inference rules to the NMake Makefiles to also look for the
+ sources that are in untracked/, and to ensure that the generated MSVC
+ build files (sigc++-config.h and sigc.rc) are copied into
+ untracked/MSVC_NMake, so that they can be built properly even with
+ NMake.
+
+2019-12-29 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ meson: Build Windows .rc files on Windows
+
+ This ensures that on Windows, the version info resources are indeed
+ linked into the libsigc++ DLL.
+
+2019-12-29 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ meson/Windows: Fix builds when builddir is a subdir of source tree
+
+ It appears that Meson did not construct the paths properly for
+ shutil.copy2() when building in a build directory that is a
+ subdirectory of the sources, when using meson.current_build_dir(),
+ possibly due how path separators are handled.
+
+ Fix this by constructing the paths using project_build_root / 'MSVC_NMake'.
+
+2019-12-29 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ meson.build: Fix 'meson dist' on Windows
+
+ Since we are assured that we are using Python 3.x on when we run Meson, we
+ do not really need to look for the 'python3' executable, but we could
+ just use whatever Python interpreter that is used to run Meson.
+
+ This will fix situations where it is commonly the case where we may have
+ multiple Python 3.x installations on Windows (www.python.org, and those
+ from Cygwin/mingw-w64), so that Meson really uses one and only one
+ Python installation to run everything that is Python-related, which will
+ thus fix '[meson|ninja] dist' on Visual Studio builds.
+
+2019-12-29 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ Meson/MSVC: Support builds directly from GIT checkouts
+
+ It appears that if one uses the m4 that is given by mingw-w64 (and
+ perhaps Cygwin), that m4 is enough to generate the sources and headers
+ that we need for the build.
+
+ So, remove the lines saying building directly from GIT checkouts are not
+ supported.
+
+2019-12-24 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ meson: Ensure symbols are exported on MSVC builds
+
+ Make sure the correct build macros are specified when building
+ libsigc++, so that:
+
+ -The symbols are properly exported
+ -We do not break builds as a result of unecesary warnings
+
+2019-12-24 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ meson: Relax MSVC version requirement to 2015
+
+ libsigc++ requires a C++-11-compliant compiler, so we can just make the
+ build look for Visual Studio 2015 instead of Visual Studio 2017 15.7.
+
+ Visual Studio 2013 also works, but since it will spew out loads of
+ warnings and the latest C++-11 version of glibmm is not buildable with
+ Visual Studio 2013, let's just require Visual Studio 2015.
+
+2019-12-24 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ Add support for building libsigc++-2.0 with Meson
+
+ libsigc++-2.0 can be built with either Autotools or Meson.
+
+2019-12-10 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ Make libsigc_manual.xml valid
+
+ Fix errors reported by "xmllint --postvalid".
+
+2019-07-03 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ tests/test_track_obj: Fix for clang++
+
+ clang++ complains if private members are unused, so make them protected.
+
+ error: private field 'bar_' is not used [-Werror,-Wunused-private-field]
+
+2019-06-12 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ 2.10.2
+
+2018-11-11 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ Create only .tar.xz tarballs
+
+ * configure.ac: This is what ftp.gnome.org wants, so this avoids
+ it doing any repackaging. This is what gtkmm does.
+
+2018-10-30 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ 2.10.1
+
+2018-10-30 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ tests: Catch exceptions by const ref
+
+ To avoid "error: catching polymorphic type ‘class std::range_error’ by value"
+
+2018-10-30 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ Update README and .gitignore
+
+2018-10-30 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ builds: Add README file for MSVC builds
+
+ Let people know how Visual Studio builds can be done and the options
+ that can be used for the builds.
+
+2018-10-30 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ builds: Remove Visual Studio 2013 projects
+
+ The NMake Makefiles superseded them, so let's just remove them.
+
+ This will make builds with later Visual Studio versions simpler, and
+ will make maintaining the Visual Studio build files easier.
+
+2018-10-30 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ builds: Add NMake Makefiles
+
+ This adds a set of NMake Makefiles that can be used to build
+ libsigc++-2.10.x (and the later C++11 versions of libsigc++) with Visual
+ Studio 2013 or later. Building the example, the tests and the
+ benchmarking programs are supported in addition to building the main
+ libsigc++ DLL.
+
+ Note that for the C++-11 releases, we name the DLLs and LIBs as
+ sigc-vc140-2_0.[dll|lib] or sigc-vc140-d-2_0.[dll|lib] for Visual Studio
+ 2015 and 2017 builds as these builds link to the msvcp140[d].dll and
+ vcruntime140[d].dll C/C++ runtime DLLs.
+
+ This set of NMake Makefiles are now dist'ed in place of the Visual
+ Studio 2013 project files.
+
+2018-10-30 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ build: Consolidate source listing into sigc++/filelist.am
+
+ This is for enabling the upcoming NMake Makefiles to use this file
+ as well, in addition to the autotools build files, to build the
+ libsigc++ DLL.
+
+2018-10-30 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ builds: Rename MSVC_Net2013 as MSVC_NMake
+
+ This is to prepare for the transition for the Visual Studio build
+ files to NMake Makefiles.
+
+2018-08-29 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ slot, signal: Avoid compiler warnings from function pointer conversions
+
+ gcc8 -Wextra prints a warning when a single reinterpret_cast is used for
+ conversion between different types of function pointers. The previous fix
+ with a union in sigc::internal::bitwise_equivalent_cast<>() is not standard
+ C++. Rename the function to function_pointer_cast<>(), and use two
+ reinterpret_casts as recommended in gcc's documentation.
+
+ Fixes #8
+
+2018-08-02 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ Update libsigcplusplus.doap
+
+2018-08-02 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ configure.ac: Update home page and bug report address
+
+2018-08-02 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ README: Update contact information
+
+2018-07-17 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ Qualify calls to bitwise_equivalent_cast() with namespace names
+
+ Otherwise indirect calls from glibmm, with its own bitwise_equivalent_cast(),
+ can be ambiguous due to ADL (argument-dependent lookup).
+
+2018-07-16 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ slot, signal: Avoid compiler warnings from function pointer conversions
+
+ gcc8 -Wextra prints a warning when reinterpret_cast is used for conversion
+ between different types of function pointers. Avoid that by adding
+ sigc::internal::bitwise_equivalent_cast<>() with a union with members of
+ the two types of function pointers.
+
+ Fixes #1
+
+2018-07-16 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ Revert "slot, signal: Avoid compiler warnings from function pointer conversions"
+
+ This reverts commit c6262e0a477b35cd9a4a00c34f3f0a44dcd07210.
+
+ This can be done in a better way by keeping the union in a template function.
+
+2018-07-13 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ slot, signal: Avoid compiler warnings from function pointer conversions
+
+ gcc8 -Wextra prints a warning when reinterpret_cast is used for conversion
+ between different types of function pointers. Avoid that by instead using
+ a union with members of the two types of function pointers.
+
+ Fixes #1
+
+2017-11-09 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ signal_base docs: Warn against deletion during emission
+
+ There is no known ABI-preserving fix for a memory leak, if a signal
+ is deleted during emission. Describe a workaround in the documentation.
+ Bug 167714
+
+2017-11-09 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ slot_base::set_parent(): Create a dummy slot_rep if necessary
+
+ set_parent() must always store the supplied parent pointer and cleanup
+ function pointer, or else there may be a memory leak. The pointers are
+ stored in slot_rep. Bug 167714
+
+2017-07-17 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ test_signal: Test calls to signal_base::clear()
+
+ Call it both during signal emission and otherwise. Bug 784550
+
+2017-07-17 Kjell Ahlstedt <kjellahlstedt@gmail.com>
+
+ signal_impl::clear(): Don't clear the slot list during signal emission
+
+ If signal_impl::clear() is called during signal emission, don't call
+ slots_.clear(). Let signal_impl::sweep() erase all slots after the signal
+ emission. Bug 784550
+
+2016-11-20 Christophe Lermytte <gentoo@lermytte.be>
+
+ Make --disable-benchmark work
+
+ Currently, when calling ./configure, the possible outcomes of the
+ enable_benchmark variable are:
+
+ ./configure -> ""
+ ./configure --enable-benchmark -> "yes"
+ ./configure --enable-benchmark=yes -> "yes"
+ ./configure --enable-benchmark=no -> "yes"
+ ./configure --enable-benchmark=hello -> "yes"
+ ./configure --disable-benchmark -> "yes"
+
+ With this commit, those values become
+
+ ./configure -> ""
+ ./configure --enable-benchmark -> "yes"
+ ./configure --enable-benchmark=yes -> "yes"
+ ./configure --enable-benchmark=no -> "no"
+ ./configure --enable-benchmark=hello -> "hello"
+ ./configure --disable-benchmark -> "no"
+
+ Note that enable_benchmark is currently only being checked for
+ being "yes" or not.
+
+ Bug #774732
+
+2016-09-20 Murray Cumming <murrayc@murrayc.com>
+
+ 2.10.0
+
+2016-07-18 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ Build: Fix silent builds
+
+ * configure.ac: Pass yes to AM_SILENT_RULES, thus enabling silent builds.
+ Replace MM_AX_CXX_COMPILE_STDCXX_11 by MM_AX_CXX_COMPILE_STDCXX (not necessary
+ for silent builds).
+ * docs/reference/Doxyfile.in: Set QUIET=YES.
+ Update for doxygen 1.8.11 (not necessary for silent builds).
+ Bug #768797
+
+2016-07-06 Murray Cumming <murrayc@murrayc.com>
+
+ 2.9.3
+
+2016-07-05 Murray Cumming <murrayc@murrayc.com>
+
+ signal: Deprecate slots().
+
+ Because we don't use it in any tests or examples and probably
+ nobody uses it. It has already been removed from libsigc++-3.0
+ (which installs in parallel):
+ https://git.gnome.org/browse/libsigcplusplus/commit/?id=fb5d1a55ddd843a1ded635b0ebce4e5b5301fc36
+
+ Please tell us if you really need to use this.
+
+2016-07-05 Murray Cumming <murrayc@murrayc.com>
+
+ signal: Deprecate emit_reverse().
+
+ Because we don't use it in any tests or examples and probably nobody
+ uses it. It has already been removed from libsigc++-3.0 (which installs
+ in parallel):
+ https://git.gnome.org/browse/libsigcplusplus/commit/?id=1a4eee7e8ded2acea94e27af5c94e37dcd9cbb13
+
+ Please tell us if you really need to use this.
+
+2016-06-21 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ Update tests/.gitignore
+
+2016-06-17 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ Fix build of "Implement slot<R(Arg...)> with variadic template"
+
+ * sigc++/functors/macros/slot.h.m4: Fix the use of operator() in the
+ variadic templates usage in the base slot_call as the syntax differs
+ between compilers for this call. This fixes the build of the tests and
+ any items that makes use of sigc++/functors/slot.h on non-GCC,
+ specifically Visual Studio 2013 and 2015.
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=767777
+
+2016-06-17 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ Visual Studio builds: Update project
+
+ Remove the sources from the projects that have been removed from the
+ source tree lately.
+
+2016-04-20 Murray Cumming <murrayc@murrayc.com>
+
+ Update tests/.gitignore
+
+2016-04-20 Murray Cumming <murrayc@murrayc.com>
+
+ benchmark: Use boost::timer instead of Glib::Timer.
+
+ And optionally build it, when --enable-benchmark is passed to configure.
+
+2016-04-20 Murray Cumming <murrayc@murrayc.com>
+
+ benchmark: Use the newer syntax.
+
+2016-04-20 Murray Cumming <murrayc@murrayc.com>
+
+ benchmark: Increase count.
+
+2016-04-20 Murray Cumming <murrayc@murrayc.com>
+
+ benchmark: Make the 1000 a constant, so we can change it.
+
+2016-04-20 Murray Cumming <murrayc@murrayc.com>
+
+ benchmark: Rearrange.
+
+2016-04-20 Murray Cumming <murrayc@murrayc.com>
+
+ benchmark: Add copyright header.
+
+2016-04-20 Murray Cumming <murrayc@murrayc.com>
+
+ benchmark: Update for the newer libsigc++ API.
+
+2016-04-08 Murray Cumming <murrayc@murrayc.com>
+
+ 2.9.2
+
+2016-04-02 Murray Cumming <murrayc@murrayc.com>
+
+ C++11: signal: Use a range-based for loop.
+
+2016-04-02 Murray Cumming <murrayc@murrayc.com>
+
+ C++11: signal: Use auto for iterators.
+
+2016-04-01 Murray Cumming <murrayc@murrayc.com>
+
+ Remove unnecessary signal.cc file.
+
+2016-04-01 Murray Cumming <murrayc@murrayc.com>
+
+ Remove unnecessary slot.cc file.
+
+2016-04-01 Murray Cumming <murrayc@murrayc.com>
+
+ docs: slots: Fix tiny typo.
+
+2016-04-01 Murray Cumming <murrayc@murrayc.com>
+
+ docs: mem_fun: Improve the simple description.
+
+2016-04-01 Murray Cumming <murrayc@murrayc.com>
+
+ docs: mem_fun: Improve the note about auto-disconnection.
+
+ Because "cleared" doesn't really tell us how this benefits us.
+
+2016-04-01 Murray Cumming <murrayc@murrayc.com>
+
+ docs: slots: Mention automatic disconnection.
+
+2016-04-01 Murray Cumming <murrayc@murrayc.com>
+
+ docs: slots: auto: Mention why it is bad.
+
+2016-04-01 Murray Cumming <murrayc@murrayc.com>
+
+ test_mem_fun: Test auto-disconnection with trackable.
+
+ This is probably tested somewhere else already, but I like having it
+ here too because it is an important reason for slot<> to exist,
+ compared to a simple std::function.
+
+2016-04-01 Murray Cumming <murrayc@murrayc.com>
+
+ test_mem_fun: Rearrange into individual test functions.
+
+2016-04-01 Murray Cumming <murrayc@murrayc.com>
+
+ docs: Slots: Add section titles to break it up.
+
+2016-03-16 Murray Cumming <murrayc@murrayc.com>
+
+ 2.9.1
+
+2016-03-16 Murray Cumming <murrayc@murrayc.com>
+
+ Update NEWS from 2.8.0
+
+2016-03-16 Murray Cumming <murrayc@murrayc.com>
+
+ test_retype: Add test of R(Args...) syntax.
+
+2016-03-16 Murray Cumming <murrayc@murrayc.com>
+
+ test_retype: Break into smaller tests.
+
+2016-03-16 Murray Cumming <murrayc@murrayc.com>
+
+ Reference docs: Main page: Mention CMake.
+
+ And generally make this like the version in master for libsigc++-3.0.
+
+2016-03-15 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ Implement slot<R(Arg...)> with variadic template
+
+ * sigc++/functors/macros/slot.h.m4: Implement the function-style slot<R<Arg...)>
+ with variadic template, as in libsigc++-3.0.
+ The primary slot_call and the slot<T_return(T_arg...)> specialization are copied
+ from libsigc++-3.0. A slot_call<T_functor, T_return> specialization is added.
+ Bug #763393
+
+2016-03-12 Murray Cumming <murrayc@murrayc.com>
+
+ slot: Document older syntax as deprecated
+
+2016-03-12 Murray Cumming <murrayc@murrayc.com>
+
+ signal: Document older syntax as deprecated.
+
+2016-03-12 Murray Cumming <murrayc@murrayc.com>
+
+ signal: Use the slot<R(Args..)> syntax.
+
+2016-03-12 Murray Cumming <murrayc@murrayc.com>
+
+ signal.h.m4: Slight reorganization of m4 code.
+
+2016-03-12 Murray Cumming <murrayc@murrayc.com>
+
+ slot.h.m4: Slight reorganisation of m4 code.
+
+2016-03-12 Murray Cumming <murrayc@murrayc.com>
+
+ signal: Allow sigc::signal<R(Args...)> declaration, like std::function.
+
+ By adding template specializations that repeats the signal*
+ template declarations, though it would be good to avoid the repetition.
+
+ Bug 763393
+
+2016-03-12 Murray Cumming <murrayc@murrayc.com>
+
+ slot: Allow sigc::slot<R(Args...)> declaration, like std::function.
+
+ By adding a template specialization that repeats each slot*<>
+ declarartion, though it would be good to avoid the repetition.
+
+ Bug 763393
+
+2016-03-11 Murray Cumming <murrayc@murrayc.com>
+
+ 2.7.2
+
+2016-03-11 Murray Cumming <murrayc@murrayc.com>
+
+ test_accumulated(): Restructure this.
+
+ To make it clearer and to keep the small tests more self-contained and
+ separate.
+
+2016-03-11 Murray Cumming <murrayc@murrayc.com>
+
+ test_signal: Add test_simple().
+
+2016-03-11 Murray Cumming <murrayc@murrayc.com>
+
+ test_signal(): Restructure this.
+
+ To make it clearer and to keep the small tests more self-contained and
+ separate.
+
+2016-03-11 Murray Cumming <murrayc@murrayc.com>
+
+ test_slot(): Restructure this.
+
+ To make it clearer and to keep the small tests more self-contained and
+ separate.
+
+2016-03-10 Murray Cumming <murrayc@murrayc.com>
+
+ signal: make_slot(): Use non-deprecated constructor.
+
+2016-03-10 Murray Cumming <murrayc@murrayc.com>
+
+ tests: Prefer the non-deprecated mem_fun(reference, func) form.
+
+2016-03-10 Murray Cumming <murrayc@murrayc.com>
+
+ tests: Use std::ref() instead of deprecated sigc::ref().
+
+2016-03-10 Murray Cumming <murrayc@murrayc.com>
+
+ examples: Don't use deprecated mem_fun(pointer, func).
+
+2016-03-10 Murray Cumming <murrayc@murrayc.com>
+
+ examples build: Disable deprecated API.
+
+2016-03-10 Murray Cumming <murrayc@murrayc.com>
+
+ mem_fun(): Deprecate mem_fun(pointer, func).
+
+ Leaving just mem_fun(reference, func).
+ See bug #763215
+
+ The deprecated mem_fun() has been removed from libsigc+--3.0,
+ so this is a chance to adapt code before switching to libsigc++-3.0.
+
+2016-03-10 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ MSVC builds: Update sigc++ project
+
+ Add the new source files and headers from adaptors/lambda, and re-order
+ the source files list into alphabetical order.
+
+2016-03-08 Murray Cumming <murrayc@murrayc.com>
+
+ Also ifdef out bound_argument<sigc::reference_wrapper>.
+
+ And add a specialization for bound_argument<std::reference_wrapper>.
+
+2016-03-08 Murray Cumming <murrayc@murrayc.com>
+
+ reference_wrapper: Include <functional>.
+
+2016-03-08 Murray Cumming <murrayc@murrayc.com>
+
+ Deprecate sigc::ref() in favor of std::ref().
+
+2016-03-07 Murray Cumming <murrayc@murrayc.com>
+
+ .doap: Correct the web site URL.
+
+ Though we really must stop using sourceforge even for the web site.
+
+2016-03-07 Murray Cumming <murrayc@murrayc.com>
+
+ Rename our .doap file.
+
+2016-03-07 Murray Cumming <murrayc@murrayc.com>
+
+ Fix tiny typo in a comment.
+
+2016-03-06 Murray Cumming <murrayc@murrayc.com>
+
+ docs: Refer to it as libsigc++, not libsigc++2.
+
+2016-03-06 Murray Cumming <murrayc@murrayc.com>
+
+ website/README: Mention the new git repository.
+
+2016-03-03 Murray Cumming <murrayc@murrayc.com>
+
+ SIGC_CXX_HAS_SUN_REVERSE_ITERATOR: Add std:: now that I removed the using std.
+
+ See https://bugzilla.gnome.org/show_bug.cgi?id=762065#c2
+
+2016-03-03 Murray Cumming <murrayc@murrayc.com>
+
+ C++11: Make all operator bool() explicit.
+
+2016-03-03 Murray Cumming <murrayc@murrayc.com>
+
+ Remove now-unnecessary SIGC_CXX_HAS_NAMESPACE_STD() configure check.
+
+ Bug #762065 (Kjell Ahlstedt)
+
+2016-03-03 Murray Cumming <murrayc@murrayc.com>
+
+ Remove unused SIGC_CXX_SELF_REFERENCE_IN_MEMBER_INITIALIZATION() configure check.
+
+ Bug #762065 (Kjell Ahlstedt)
+
+2016-03-02 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ Improve the documentation of mem_fun()
+
+ * sigc++/functors/macros/mem_fun.h.m4:
+ * sigc++/functors/slot_base.h: Make it clear that mem_fun() does not return
+ a slot, and 'auto s = sigc::mem_fun(....)' is not equivalent to
+ 'sigc::slot<....> s = sigc::mem_fun(....)'.
+ The confusing documentation was noted by Andrejs Hanins on libsigc-list.
+
+2016-03-01 Murray Cumming <murrayc@murrayc.com>
+
+ Add test_bind_as_slot.
+
+ This tests sigc::bind()'s indirect use of adaptor_functor<>.
+ I added this because this doesn't work yet in the variadic_bind branch.
+
+2016-03-01 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ 2.7.1
+
+2016-01-14 Murray Cumming <murrayc@murrayc.com>
+
+ m4: Remove unused UPPER and LOWER functions.
+
+2016-01-14 Murray Cumming <murrayc@murrayc.com>
+
+ tests: Use = delete instead of private constructors.
+
+ To make classes non-copyable.
+
+2016-01-07 Murray Cumming <murrayc@murrayc.com>
+
+ functor_trait.m4: Correct the mem_functor<> declarations.
+
+ The first template types are T_return and T_obj, not the arguments.
+ This doesn't seem to have been a problem. Maybe this code is not tested
+ or used.
+
+2015-12-17 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ Don't use SIGC_USING_STD()
+
+ The SIGC_USING_STD() macro is defined as an empty string, if some standard
+ C++ symbols are defined in namespace std. They always are.
+ Since many years, SIGC_USING_STD() is an unnecessary macro.
+
+2015-12-16 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ Temporarily undefine the nil macro, if it's defined
+
+ * build/cxx.m4: Add SIGC_CXX_PRAGMA_PUSH_POP_MACRO.
+ * configure.ac: Call SIGC_CXX_PRAGMA_PUSH_POP_MACRO.
+ * sigc++config.h.in: Add SIGC_PRAGMA_PUSH_POP_MACRO.
+ * sigc++/functors/macros/functor_trait.h.m4:
+ * sigc++/adaptors/macros/bind.h.m4:
+ * sigc++/adaptors/macros/retype.h.m4:
+ * sigc++/functors/macros/slot.h.m4:
+ * sigc++/macros/signal.h.m4: If nil and SIGC_PRAGMA_PUSH_POP_MACRO are
+ defined, undefine nil temporarily in the header files.
+ nil is a keyword in Objective-C++ and in Mac OS X C++. Bug #695235.
+
+2015-12-15 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ can_deduce_result_type_with_decltype: Rename the check() methods
+
+ * sigc++/functors/macros/functor_trait.h.m4: Rename the check() methods.
+ check() is a preprocessor macro in Mac OS X. Bug #759315.
+
+2015-12-13 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ Fix some typos
+
+2015-11-16 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ Add a moving signal::connect() overload
+
+ * sigc++/macros/signal.h.m4: Add signal#::connect(slot_type&&),
+ slot_list::insert(iterator i, slot_type&&),
+ slot_list::push_front(slot_type&&), push_back(slot_type&&).
+ * sigc++/signal_base.[h|cc]: Add signal_base::connect(slot_base&&),
+ signal_base::insert(slot_base&&), signal_impl::connect(slot_base&&),
+ signal_impl::insert(slot_base&&). Bug #756484.
+
+2015-11-13 Murray Cumming <murrayc@murrayc.com>
+
+ 2.6.2
+
+2015-11-12 Murray Cumming <murrayc@murrayc.com>
+
+ Add warnings for use with --enable-warnings=fatal
+
+ Added use -Wsuggest-override and -Wzero-as-null-pointer-constant.
+
+2015-11-10 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ trackable, slot_base, signal_base, connection: Add some noexcept specs
+
+2015-11-08 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ slot and signal: Add missing move constructors and move assignments
+
+ * sigc++/functors/macros/slot.h.m4: Add move operators for slot<>.
+ * sigc++/macros/signal.h.m4: Add move operators for signal#<> and signal<>.
+ * tests/test_signal_move.cc:
+ * tests/test_slot_move.cc: Test that the source objects are empty.
+ Bug #756484.
+
+2015-11-08 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ trackable, slot, signal: Remove noexcept specifications
+
+ * sigc++/functors/macros/slot.h.m4:
+ * sigc++/functors/slot_base.[h|cc]:
+ * sigc++/signal_base.[h|cc]:
+ * sigc++/trackable.[h|cc]: Remove noexcept from the move operators.
+ Bug #756484.
+
+2015-11-06 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ slot: Handle auto-disconnection when a slot contains a slot
+
+ * sigc++/functors/macros/slot.h.m4: Add sigc::visitor<> specializations
+ for slot# and slot.
+ * tests/test_disconnect.cc: Test auto-disconnection of a slot that contains
+ a slot. Bug #755003.
+
+2015-11-06 Murray Cumming <murrayc@murrayc.com>
+
+ signal_impl: =delete copy and move operations.
+
+ Prevent, copy and move constructors and assignment operators from
+ being generated automatically. These are never used, but this
+ will make sure of that.
+ See https://bugzilla.gnome.org/show_bug.cgi?id=756484#c5
+
+2015-11-06 Murray Cumming <murrayc@murrayc.com>
+
+ typed_slot_rep: =delete unimplemented copy and move operations.
+
+ Prevent, copy assignment operator, move constructor and move
+ assignment operators from being generated automatically.
+ These are never used, but this will make sure of that.
+ See https://bugzilla.gnome.org/show_bug.cgi?id=756484#c5
+
+2015-11-06 Murray Cumming <murrayc@murrayc.com>
+
+ slot_rep: =delete copy and move operations.
+
+ Prevent, copy and move constructors and assignment operators from
+ being generated automatically. These are never used, but this
+ will make sure of that.
+ See https://bugzilla.gnome.org/show_bug.cgi?id=756484#c5
+
+2015-11-06 Murray Cumming <murrayc@murrayc.com>
+
+ Small whitespace changes in docs comment.
+
+2015-10-31 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ trackable: Add a comment
+
+2015-10-21 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ slot and signal: Fix move constructors and move assignments
+
+ * sigc++/functors/macros/slot.h.m4: Add documentation.
+ * sigc++/functors/slot_base.[h|cc]: Fix the move operators of slot_base.
+ Don't move a connected slot.
+ * sigc++/signal_base.cc: Fix the move assignment of signal_base.
+ * tests/test_signal_move.cc:
+ * tests/test_slot_move.cc: Really test move assignment. Bug #756484.
+
+2015-10-13 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ More use of nullptr instead of 0
+
+2015-10-11 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ slot_rep::disconnect(): Remove a comment, add a test
+
+ * sigc++/functors/slot_base.cc: Remove a TODO comment at slot_rep::disconnect().
+ * tests/test_slot_disconnect.cc: Add a test that assigns an empty slot.
+
+2015-09-29 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ Update sigc++/.gitignore
+
+2015-09-27 Murray Cumming <murrayc@murrayc.com>
+
+ 2.6.1
+
+2015-09-26 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ sigc::trackable: Don't move the callback list
+
+ * sigc++/trackable.[h|cc]: Don't move the callback list.
+ * tests/test_trackable_move.cc: Remove a comment. Bug #755393.
+
+2015-09-26 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ Recreate adaptors/lambda files necessary not to break ABI
+
+ * sigc++/adaptors/lambda/macros/base.h.m4:
+ * sigc++/adaptors/lambda/macros/lambda.cc.m4:
+ * sigc++/adaptors/lambda/macros/select.h.m4: Recreate these files.
+ * sigc++/Makefile.am:
+ * sigc++/filelist.am: Add the recreated lambda files.
+ Approximately a reversion of commit a259b4c7a1753dbc389ee467fa536339ec820223,
+ "Remove remaining parts of the sigc::lambda API."
+ Differences from an exact reversion: MSVC_Net files are not modified.
+ (Probably something ought to be changed in MSVC_Net2013.)
+ tests/Makefile.am is not modified-
+ is_base_and_derived<> is replaced by std::is_base_of<> in base.h.m4.
+ The extern declarations that were previously in select.h.m4 are moved to
+ lambda.cc.m4. Without them, sigc::_1 .. sigc::_7 are not included in
+ the .so file.
+ All code in the header files are inside #ifndef DOXYGEN_SHOULD_SKIP_THIS.
+ Bug #755550.
+
+2015-09-21 Murray Cumming <murrayc@murrayc.com>
+
+ 2.6.0
+
+2015-09-17 Murray Cumming <murrayc@murrayc.com>
+
+ C++11: deduce_result_type: Simpifying, removing use of std::is_same().
+
+ See https://bugzilla.gnome.org/show_bug.cgi?id=753612#c9
+
+2015-09-17 Marcin Kolny <marcin.kolny@gmail.com>
+
+ C++11: deduce_result_type: build fix, using SFINAE paradigm.
+
+ Bug #753612
+
+2015-09-17 Murray Cumming <murrayc@murrayc.com>
+
+ C++11: deduce_result_type: Simplify with variadic template and std::conditional<>.
+
+ Bug #753612
+ However, the build then fails like so:
+
+ make[2]: Entering directory '/home/murrayc/checkout/gnome/libsigc++2/examples'
+ g++ -DHAVE_CONFIG_H -I.. -I.. -pedantic -Wall -Wextra -Wshadow -Wformat-security -Werror -Wall -g -O0 -std=c++11 -MT hello_world.o -MD -MP -MF .deps/hello_world.Tpo -c -o hello_world.o hello_world.cc
+ In file included from ../sigc++/adaptors/adaptor_trait.h:10:0,
+ from ../sigc++/functors/slot.h:7,
+ from ../sigc++/signal_base.h:27,
+ from ../sigc++/signal.h:8,
+ from ../sigc++/sigc++.h:86,
+ from hello_world.cc:10:
+ ../sigc++/adaptors/deduce_result_type.h: In instantiation of ‘struct sigc::deduce_result_type<sigc::pointer_functor1<const std::basic_string<char>&, void>, const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, void, void, void, void, void, void>’:
+ ../sigc++/adaptors/deduce_result_type.h:60:80: required by substitution of ‘template<class T_functor, class ... T_args> using deduce_result_t = typename sigc::deduce_result_type::type [with T_functor = sigc::pointer_functor1<const std::basic_string<char>&, void>; T_args = {const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, void, void, void, void, void, void}]’
+ ../sigc++/adaptors/adaptor_trait.h:67:104: required from ‘struct sigc::adaptor_functor<sigc::pointer_functor1<const std::basic_string<char>&, void> >::deduce_result_type<const std::basic_string<char>&, void, void, void, void, void, void>’
+ ../sigc++/adaptors/adaptor_trait.h:88:3: required by substitution of ‘template<class T_arg1> typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type sigc::adaptor_functor<T_functor>::operator()(T_arg1) const [with T_arg1 = const std::basic_string<char>&]’
+ ../sigc++/functors/slot.h:137:20: required from ‘static T_return sigc::internal::slot_call1<T_functor, T_return, T_arg1>::call_it(sigc::internal::slot_rep*, sigc::type_trait_take_t<T_arg3>) [with T_functor = sigc::pointer_functor1<const std::basic_string<char>&, void>; T_return = void; T_arg1 = const std::basic_string<char>&; sigc::type_trait_take_t<T_arg3> = const std::basic_string<char>&]’
+ ../sigc++/functors/slot.h:144:37: required from ‘static void* (* sigc::internal::slot_call1<T_functor, T_return, T_arg1>::address())(void*) [with T_functor = sigc::pointer_functor1<const std::basic_string<char>&, void>; T_return = void; T_arg1 = const std::basic_string<char>&; sigc::internal::hook = void* (*)(void*)]’
+ ../sigc++/functors/slot.h:529:91: required from ‘sigc::slot1<T_return, T_arg1>::slot1(const T_functor&) [with T_functor = sigc::pointer_functor1<const std::basic_string<char>&, void>; T_return = void; T_arg1 = const std::basic_string<char>&]’
+ ../sigc++/functors/slot.h:1161:26: required from ‘sigc::slot<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const T_functor&) [with T_functor = sigc::pointer_functor1<const std::basic_string<char>&, void>; T_return = void; T_arg1 = const std::basic_string<char>&]’
+ hello_world.cc:25:50: required from here
+ ../sigc++/adaptors/deduce_result_type.h:56:12: error: no class template named ‘deduce_result_type’ in ‘class sigc::pointer_functor1<const std::basic_string<char>&, void>’
+ >::type;
+ ^
+ In file included from ../sigc++/signal_base.h:27:0,
+ from ../sigc++/signal.h:8,
+ from ../sigc++/sigc++.h:86,
+ from hello_world.cc:10:
+ ../sigc++/functors/slot.h: In instantiation of ‘static T_return sigc::internal::slot_call1<T_functor, T_return, T_arg1>::call_it(sigc::internal::slot_rep*, sigc::type_trait_take_t<T_arg3>) [with T_functor = sigc::pointer_functor1<const std::basic_string<char>&, void>; T_return = void; T_arg1 = const std::basic_string<char>&; sigc::type_trait_take_t<T_arg3> = const std::basic_string<char>&]’:
+ ../sigc++/functors/slot.h:144:37: required from ‘static void* (* sigc::internal::slot_call1<T_functor, T_return, T_arg1>::address())(void*) [with T_functor = sigc::pointer_functor1<const std::basic_string<char>&, void>; T_return = void; T_arg1 = const std::basic_string<char>&; sigc::internal::hook = void* (*)(void*)]’
+ ../sigc++/functors/slot.h:529:91: required from ‘sigc::slot1<T_return, T_arg1>::slot1(const T_functor&) [with T_functor = sigc::pointer_functor1<const std::basic_string<char>&, void>; T_return = void; T_arg1 = const std::basic_string<char>&]’
+ ../sigc++/functors/slot.h:1161:26: required from ‘sigc::slot<T_return, T_arg1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const T_functor&) [with T_functor = sigc::pointer_functor1<const std::basic_string<char>&, void>; T_return = void; T_arg1 = const std::basic_string<char>&]’
+ hello_world.cc:25:50: required from here
+ ../sigc++/functors/slot.h:137:20: error: no matching function for call to ‘sigc::adaptor_functor<sigc::pointer_functor1<const std::basic_string<char>&, void> >::operator()(const std::basic_string<char>&)’
+ (a_1);
+ ^
+ ../sigc++/functors/slot.h:137:20: note: candidates are:
+ In file included from ../sigc++/functors/slot.h:7:0,
+ from ../sigc++/signal_base.h:27,
+ from ../sigc++/signal.h:8,
+ from ../sigc++/sigc++.h:86,
+ from hello_world.cc:10:
+ ../sigc++/adaptors/adaptor_trait.h:88:3: note: template<class T_arg1> typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type sigc::adaptor_functor<T_functor>::operator()(T_arg1) const [with T_arg1 = T_arg1; T_functor = sigc::pointer_functor1<const std::basic_string<char>&, void>]
+ operator()(T_arg1 _A_arg1) const
+ ^
+ ../sigc++/adaptors/adaptor_trait.h:88:3: note: substitution of deduced template arguments resulted in errors seen above
+ ../sigc++/adaptors/adaptor_trait.h:107:3: note: template<class T_arg1, class T_arg2> typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1, T_arg2>::type sigc::adaptor_functor<T_functor>::operator()(T_arg1, T_arg2) const [with T_arg1 = T_arg1; T_arg2 = T_arg2; T_functor = sigc::pointer_functor1<const std::basic_string<char>&, void>]
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2) const
+ ^
+ ../sigc++/adaptors/adaptor_trait.h:107:3: note: template argument deduction/substitution failed:
+ In file included from ../sigc++/signal_base.h:27:0,
+ from ../sigc++/signal.h:8,
+ from ../sigc++/sigc++.h:86,
+ from hello_world.cc:10:
+ ../sigc++/functors/slot.h:137:20: note: candidate expects 2 arguments, 1 provided
+ (a_1);
+ ^
+
+2015-09-11 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ MSVC Builds: Add "Install" Project
+
+ This makes building the -mm stack easier by copying the headers and the
+ built DLL, PDB and LIB files to a location where it can be picked up by
+ the gtkmm stack automatically, when they are extracted in a common
+ directory. This is what is currently done with the GTK+ and Clutter
+ stacks for Visual Studio builds.
+
+2015-09-09 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ Update README on Visual Studio Builds
+
+ Since the Visual Studio project files and the related sources have been
+ updated to work with Visual Studio 2013, and that the test programs do
+ run well there, update the README file to let people know the situation.
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=754082
+
+2015-09-09 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ sigc++config.h.in: Allow Build for MSVC 2013
+
+ MSVC 2013 does not have the C++-11 noexcept, so we need to define that to
+ _NOEXCEPT for MSVC 2013. Plus, since by default MSVC 2013 does not allow
+ us to re-define keywords, though they may or may not be supported, we need
+ to use the _ALLOW_KEYWORD_MACROS macro to allow this to happen.
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=754082
+
+2015-09-08 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ Update source of web page
+
+ * docs/website/fragments/footer.html_fragment:
+ * docs/website/fragments/html_declaration.html_fragment:
+ * docs/website/devel.shtml:
+ * docs/website/doc.shtml:
+ * docs/website/index.shtml:
+ * docs/website/link.shtml:
+ * docs/website/stable.shtml: Fix or remove broken links. Remove the lists of
+ supported compilers. Mention that a C++11 compiler is required and that
+ support for lambdas has been removed. Bug #754082.
+
+2015-09-07 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ Update .gitignore
+
+2015-09-03 Murray Cumming <murrayc@murrayc.com>
+
+ 2.5.4
+
+2015-09-03 Murray Cumming <murrayc@murrayc.com>
+
+ Update tests/.gitignore
+
+2015-09-02 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ MSVC Builds: Use Windows Line Endings for .sln
+
+ The .sln files need to have Windows/DOS line endings to work properly so
+ that Windows can detect the Visual Studio version of the solution file.
+
+2015-09-02 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ MSVC Builds: Add Forgotten Files
+
+ The MSVC projects now use property sheets, but they were forgotten from
+ dist in the previous commits. Dist them... sorry!
+
+2015-09-02 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ MSVC Builds: Remove MSVC 2005 and 2008 projects
+
+ They are now unable to build libsigc++ at all, so drop them.
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=754082
+
+2015-09-02 Chun-wei Fan <fanchunwei@src.gnome.org>
+
+ MSVC Builds: Rename MSVC_Net2010/ to MSVC_Net2013/
+
+ Since libsigc++ now requires MSVC 2013 to build, the MSVC_Net2010 directory
+ needs to be renamed to MSVC_Net2013, so that people will not be confused on
+ what MSVC version is needed to build libsigc++. Also remove MSVC_Net2005
+ and MSVC_Net2008 from the distribution, as they are no longer able to build
+ libsigc++.
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=754082
+
+2015-09-01 Murray Cumming <murrayc@murrayc.com>
+
+ signal_base, trackable: Make move operations noexcept.
+
+2015-09-01 Murray Cumming <murrayc@murrayc.com>
+
+ Added test_signal_move.
+
+ This seems to work.
+
+2015-09-01 Murray Cumming <murrayc@murrayc.com>
+
+ Added test_slot_move
+
+ This seems to do what it should, acting much like regular slot copying.
+
+2015-09-01 Murray Cumming <murrayc@murrayc.com>
+
+ Add test_trackable_move.
+
+ It doesn't segfault, but I'm not sure it's doing what it should.
+ See the TODO.
+
+2015-09-01 Murray Cumming <murrayc@murrayc.com>
+
+ trackable: move constructor: null the src.
+
+2015-09-01 Murray Cumming <murrayc@murrayc.com>
+
+ trackable: move assignment operator: null the src.
+
--- /dev/null
+2.3.1:
+
+2012-10-18 Murray Cumming <murrayc@murray.com>
+
+ Update the Doxyfile.in syntax.
+
+ * docs/reference/Doxyfile.in: By running doxygen -u
+ on it.
+
+2012-10-17 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ 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 <kjell.ahlstedt@bredband.net>
+
+ 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 <andris.pavenis@iki.fi>
+
+ 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 <kjell.ahlstedt@bredband.net>
+
+ 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 <kjell.ahlstedt@bredband.net>
+
+ 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 <cstddef>.
+ * 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 <kjell.ahlstedt@bredband.net>
+
+ 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 <kjell.ahlstedt@bredband.net>
+
+ Update .gitignore and tests/.gitignore
+
+ * .gitignore: Add *~ (gedit's backup files).
+ * tests/.gitignore: Add missing executable test files.
+
+2012-08-28 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ 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 <kjell.ahlstedt@bredband.net>
+
+ 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 <qsorix@rydznet.pl>
+
+ 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 <kjell.ahlstedt@bredband.net>
+
+ 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 <kjell.ahlstedt@bredband.net>
+
+ 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 <kjell.ahlstedt@bredband.net>
+
+ 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 <kalev@smartlink.ee>
+
+ Fix the build with GCC 4.6
+
+ * sigc++/signal_base.h: Include <cstddef> for size_t.
+
+2010-10-12 David King <davidk@openismus.com>
+
+ 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 <armin@arbur.net>
+
+ * 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 <armin@arbur.net>
+
+ * 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 <armin@arbur.net>
+
+ * 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 <davidk@openismus.com>
+
+ 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 <murrayc@murrayc.com>
+
+ Manual: Add an id="index" attribute in case that helps library.gnome.org.
+
+ * docs/manual/libsigc_manual.xml: Add it to the <book> tag.
+
+2.2.7:
+
+2010-05-04 Murray Cumming <murrayc@murrayc.com>
+
+ 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 <davidk@openismus.com>
+
+ Improvements to main page documentation
+
+ * sigc++/sigc++.h: Minor improvements.
+
+2010-04-23 David King <davidk@openismus.com>
+
+ 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 <davidk@openismus.com>
+
+ 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 <murrayc@murrayc-desktop>
+
+ 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 <murrayc@murrayc.com>
+
+ Website: Fix the Makefile so upload works with sourceforge again.
+
+2010-04-06 Murray Cumming <murrayc@murrayc.com>
+
+ 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 <daniel.kitta@gmail.com>
+
+ 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 <tweenk.pl@gmail.com>
+
+ 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 <daniel.kitta@gmail.com>
+
+ 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 <armin@arbur.net>
+
+ * 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 <daniel.kitta@gmail.com>
+
+ 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 <michaelh@openismus.com>
+
+ 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 <daniel.kitta@gmail.com>
+
+ Enable verbose output of autoreconf
+
+ * autogen.sh: Pass --verbose option to autoreconf.
+
+2.2.4.2:
+
+2009-09-02 Daniel Elstner <danielk@openismus.com>
+
+ 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 <danielk@openismus.com>
+
+ 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 <danielk@openismus.com>
+
+ 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 <danielk@openismus.com>
+
+ 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 <danielk@openismus.com>
+
+ 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 <danielk@openismus.com>
+
+ 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 <danielk@openismus.com>
+
+ 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 <danielk@openismus.com>
+
+ 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 <danielk@openismus.com>
+
+ 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 <danielk@openismus.com>
+
+ Have Automake check NEWS and use bzip2
+
+ * configure.ac (AM_INIT_AUTOMAKE): Add options check-news and
+ dist-bzip2.
+
+2009-08-25 Daniel Elstner <danielk@openismus.com>
+
+ Update NEWS for libsigc++ 2.2.4 release
+
+2009-08-25 Daniel Elstner <danielk@openismus.com>
+
+ 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 <danielk@openismus.com>
+
+ 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 <danielk@openismus.com>
+
+ Add id="content" element to documentation index
+
+ * docs/reference/libsigc_header.html_fragment: Start <div> element
+ with attribute id="content" to match the other C++ binding modules.
+ * docs/reference/libsigc_footer.html_fragment: Close <div> element.
+
+2009-08-20 Daniel Elstner <danielk@openismus.com>
+
+ 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 <danielk@openismus.com>
+
+ 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 <danielk@openismus.com>
+
+ 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 <daniel.kitta@gmail.com>
+
+ 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 <daniel.kitta@gmail.com>
+
+ 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 <danielk@openismus.com>
+
+ 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 <danielk@openismus.com>
+
+ 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 <danielk@openismus.com>
+
+ 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 <danielk@openismus.com>
+
+ 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 <danielk@openismus.com>
+
+ 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 <danielk@openismus.com>
+
+ 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 <danielk@openismus.com>
+
+ 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 <danielk@openismus.com>
+
+ 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 <danielk@openismus.com>
+
+ 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 <danielk@openismus.com>
+
+ 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 <danielk@openismus.com>
+
+ 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 <murrayc@murrayc.com>
+
+ * 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 <armin@arbur.net>
+
+ * 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 <armin@arbur.net>
+
+ * 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 <armin@arbur.net>
+
+ * 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 <cedric.gustin@gmail.com>
+
+ * 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 <manphiz@gmail.com
+
+ * sigc++/macros/slot.h.m4:
+ Added an include of functors/slot.h that was mistakenly removed
+ during the 2.1 series, apparently breaking API slightly.
+ Bug #521418.
+
+2.2.1:
+
+2008-02-28 Elaine Xiong <elaine.xiong@sun.com>
+
+ * 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 <dirtyepic@gentoo.>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <michael@elehack.net>
+
+ * 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 <daniel.kitta@gmail.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <hpreg@vmware.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <profic@kursknet.ru>
+
+ * sigc++/macros/signal.h.m4: Fix compilation problem in
+ the last patch.
+
+2005-12-14 John Profic <profic@kursknet.ru>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * tests/Makefile.am:
+ * tests/test_slot_disconnect.cc: Added test
+ case from bug #311057.
+
+2005-11-16 Philipp Berndt <philipp.berndt@gmx.net>
+
+ * sigc++/adaptors/macros/exception_catch.h.m4: Make member
+ exception_catch_functor<T_functor, T_catcher, void>::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 <nealc@trdlnk.com>
+
+ * sigc++/signal_base.h: Updated the documentation for temp_slot_list
+ as requested in bug #303896.
+
+2005-08-01 Murray Cumming <murrayc@murrayc.com>
+
+ * 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 <brunom@fing.edu.uy>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * docs/manual/libsigc_manual.xml: Fixed typo
+ found by Antonio Coralles.
+
+2005-07-09 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/macros/signal.h.m4: Did the same (see
+ last commit) for slot_const_iterator and
+ slot_iterator_buf.
+
+2005-07-09 Murray Cumming <murrayc@murrayc.com>
+
+ * 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 <plangdale@vmware.com>
+
+ * 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 <marek.rouchal@infineon.com>
+
+ * 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 <pavenis@latnet.lv>
+
+ * 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 <pogonyshev@gmx.net>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * sigc++/visit_each.h: limit_derived_target(): Just some whitespace
+ changes.
+
+2005-05-16 Neal E. Coombes <nealc@trdlnk.com>
+
+ * 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 <kleint@bifab.de>
+
+ * 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 <hpreg@vmware.com>
+
+ * 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<Foo>' 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<Foo>' 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * sigc++/functors/macros/mem_fun.h.m4: bound_*<>:
+ Add a new is_base_and_derived<sigc::trackable>
+ 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 <murrayc@murrayc.com>
+
+ * sigc++/type_traits.h: Added comments for users of
+ g++ 3.2.
+
+2005-04-28 Murray Cumming <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <cedric.gustin@swing.be>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * tests/test_slot.cc, test_disconnect.cc: #included <new> to avoid
+ an unresolved symbol error with the Tru64 compiler. Solution found by
+ Tim Mooney in bug #161503.
+
+2005-02-20 Martin Schulze <mschulze@cvs.gnome.org>
+
+ * sigc++/signal_base.h: Add some documentation.
+
+2005-02-20 Martin Schulze <mschulze@cvs.gnome.org>
+
+ * 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 <mschulze@cvs.gnome.org>
+
+ * docs/manual/Makefile.am: Set the correct group in post-html.
+
+2005-02-11 Murray Cumming <murrayc@murrayc.com>
+
+ * docs/website/doc.shtml: Fix typo in url for reference docs. Found by
+ James Lin.
+
+2005-02-06 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/signal_base.h: temp_slot_list::begin(), end(): Actually
+ return the iterators.
+
+2005-02-03 Neal E. Coombes <nealc@trdlnk.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * sigc++/adapators/macros/base.h.m4: Add sigc::var<>() documentation,
+ from Roger Ferrer Ibáñez in bug #149483.
+
+2005-02-01 Murray Cumming <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <liza@trdlnk.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <cedric.gustin@swing.be>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * configure.in: AC_INIT(): Provide the extra tarball name parameter,
+ so that it does not create a libsigc--- tarball.
+
+2005-01-19 Murray Cumming <murrayc@murrayc.com>
+
+ * configure.in: AC_INIT(): Use libsigc++ instead of sigc++, attempting
+ to get the correct tarball name.
+
+2005-01-18 Murray Cumming <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <schussman@slac.stanford.edu>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <cedric.gustin@swing.be>
+
+ * 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 <cedric.gustin@swing.be>
+
+ * MSVC_Net2003/Makefile.am: get sigc++config.h from $(top_builddir)
+ instead of $(top_srcdir).
+
+2004-12-08 Cedric Gustin <cedric.gustin@swing.be>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <mschulze@cvs.gnome.org>
+
+ * 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 <plangdale@vmware.com>).
+
+2004-10-24 Martin Schulze <mschulze@cvs.gnome.org>
+
+ * MSVC_Net2003/*/*.vcproj: Link with the "multithreaded DLL" runtime
+ libraries and enable RTTI for the MSVC build
+ (patch from Timothy M. Shead <tshead@k-3d.com>).
+ * MSVC_Net2003/*/.cvsignore: Hide generated build files from cvs
+ (patch from Timothy M. Shead <tshead@k-3d.com>).
+
+2.0.6:
+
+2004-10-12 Martin Schulze <mschulze@cvs.gnome.org>
+
+ * 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 <mschulze@cvs.gnome.org>
+
+ * 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 <mschulze@cvs.gnome.org>
+
+ * 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 <tshead@k-3d.com>).
+
+2004-10-02 Martin Schulze <mschulze@cvs.gnome.org>
+
+ * configure.ac: Bump version number to 2.0.6.
+ * NEWS: Add ChangeLog summary for version 2.0.6.
+
+2004-10-02 Martin Schulze <mschulze@cvs.gnome.org>
+
+ * 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 <mschulze@cvs.gnome.org>
+
+ * 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 <mschulze@cvs.gnome.org>
+
+ * 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 <mschulze@cvs.gnome.org>
+
+ * sigc++/macros/object_slot.h.m4: Use correct bound_mem_functor
+ variants for const (volatile) methods (fixes #148744).
+
+2004-09-01 Martin Schulze <mschulze@cvs.gnome.org>
+
+ * docs/index.html: Correct link to lambda module.
+
+2004-09-01 Martin Schulze <mschulze@cvs.gnome.org>
+
+ * README: Update compatibility section.
+
+2.0.5:
+
+2004-09-01 Martin Schulze <mschulze@cvs.gnome.org>
+
+ * 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 <mschulze@cvs.gnome.org>
+
+ * 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 <mschulze@cvs.gnome.org>
+
+ * 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 <slimjimmy@mail.com>
+
+ * Added SIGC_API qualifier to all externally-visible non-template
+ classes/structs.
+ * Added #include <sigc++config.h> 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 <mschulze@cvs.gnome.org>
+
+ * sigc++/type_traits.h: Remove type_trait<>::instance()
+ (was unimplemented and unused; caused problems with the MSVC).
+
+2004-07-23 Martin Schulze <mschulze@cvs.gnome.org>
+
+ * 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 <mschulze@cvs.gnome.org>
+
+ * *.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 <mschulze@cvs.gnome.org>
+
+ * 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 <mschulze@cvs.gnome.org>
+
+ * 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 <mschulze@cvs.gnome.org>
+
+ * 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 <mschulze@cvs.gnome.org>
+
+ * 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 <mschulze@cvs.gnome.org>
+
+ * examples/hello_world.cc: Use sigc::ptr_fun instead of std::ptr_fun.
+ (fixes bug #144846)
+
+2004-07-11 Eric Bourque <ericb@computer.org>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * tests/: Added test_disconnect_during_emit.cc, to prove that this
+ works.
+
+2004-07-08 Murray Cumming <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <code>
+ * 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 <mschulze@cvs.gnome.org>
+
+ * autogen.sh: Add '--force'-flag to the 'libtoolize'-command (bug #143425).
+
+2.0.3:
+
+2004-05-30 Martin Schulze <mschulze@cvs.gnome.org>
+
+ * 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 <mschulze@cvs.gnome.org>
+
+ * configure.ac: Bump version number to 2.0.2.
+ * NEWS: Add ChangeLog summary for version 2.0.2.
+
+2004-05-20 Martin Schulze <mschulze@cvs.gnome.org>
+
+ * 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 <mschulze@cvs.gnome.org>
+
+ * sigc++/macros/object_slot.h.m4: Suppress compiler warning at
+ dynamic_cast<>-test (suggested by Timothy M. Shead).
+
+2004-05-01 Martin Schulze <mschulze@cvs.gnome.org>
+
+ * README: Updated for libsigc++-2.0.
+
+2.0.1:
+
+2004-04-27 Martin Schulze <mschulze@cvs.gnome.org>
+
+ * 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 <mschulze@cvs.gnome.org>
+
+ * 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 <mschulze@cvs.gnome.org>
+
+ * scripts/cxx.m4: Updated the configure check. It would probably
+ have succeeded on the Apple.
+
+2004-04-26 Martin Schulze <mschulze@cvs.gnome.org>
+
+ * 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 <mschulze@cvs.gnome.org>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <mschulze@cvs.gnome.org>
+
+ * 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 <murrayc@murrayc.com>
+
+ * sigc++/connection.[h|cc]: Implement blocked() to avoid undefined
+ symbol linker error.
+
+2004-04-08 Murray Cumming <murrayc@murrayc.com>
+
+ * dist the scripts directory.
+
+1.9.16:
+
+2004-04-06 Martin Schulze <teebaum@cvs.gnome.org>
+
+ * configure.ac: Bump version number to 1.9.16.
+ * NEWS: Add ChangeLog summary for version 1.9.16.
+
+2004-04-02 Murray Cumming <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * Makefile.am, sigc++/Makfile.am: Fix the sigc++config.h.in disting,
+ to fix make distcheck.
+
+2004-03-21 Murray Cumming <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <mschulze@cvs.gnome.org>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * configure.ac: Bump version number to 1.9.15.
+ * NEWS: Add ChangeLog summary for version 1.9.15.
+
+2004-02-27 Martin Schulze <teebaum@cvs.gnome.org>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * sigc++/type_traits.h: Make is_base_and_derived<> work with the SUN Forte.
+
+2004-02-19 Martin Schulze <teebaum@cvs.gnome.org>
+
+ * 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<T_type, true>.
+
+2004-02-14 Martin Schulze <teebaum@cvs.gnome.org>
+
+ * 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 <murrayc@usa.net>
+
+ * 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 <murrayc@murrayc.com>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * configure.ac: Bump version number to 1.9.14.
+ * NEWS: Add ChangeLog summary for version 1.9.14.
+
+2004-02-09 Murray Cumming <murrayc@usa.net>
+
+ * 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 <murrayc@usa.net>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * sigc++/functors/macros/slot.h.m4: Change functor type in
+ typed_slot_rep to adaptor_trait::adaptor_type<T_functor>
+ 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 <teebaum@cvs.gnome.org>
+
+ * configure.ac: Bump version number to 1.9.12.
+ * NEWS: Add ChangeLog summary for version 1.9.12.
+
+2003-11-03 Martin Schulze <teebaum@cvs.gnome.org>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * sigc++/[class,method,object]_slot.h.m4: Include
+ sigc++/functors/mem_fun.h (Reported by Ron Steinke).
+
+2003-11-01 Martin Schulze <teebaum@cvs.gnome.org>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * MSVC_Net2003: New directory containing project
+ files for Visual Studio .Net 2003.
+ Credits to Roel Vanhout <roel@riks.nl>!
+
+2003-11-01 Martin Schulze <teebaum@cvs.gnome.org>
+
+ * 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<T_type[N]>::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 <cedric.gustin@swing.be>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * 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 <string> where std::string is used.
+ - Use double instead of float.
+
+2003-10-27 Martin Schulze <teebaum@cvs.gnome.org>
+
+ * sigc++/retype.h.m4: Cleanup.
+ * TODO: Bring it up to date.
+
+1.9.11:
+
+2003-10-26 Martin Schulze <teebaum@cvs.gnome.org>
+
+ * configure.ac: Bump version number to 1.9.11.
+ * NEWS: Add ChangeLog summary for version 1.9.11.
+
+2003-10-26 Martin Schulze <teebaum@cvs.gnome.org>
+
+ 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 <teebaum@cvs.gnome.org>
+
+ 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 <teebaum@cvs.gnome.org>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * configure.ac: Bump version number to 1.9.10.
+ * NEWS: Add ChangeLog summary for version 1.9.10.
+
+2003-10-23 Martin Schulze <teebaum@cvs.gnome.org>
+
+ * sigc++/functors/{functor_trait,slot}.h.m4:
+ Move definition of struct nil into functor_trait.h.
+
+2003-10-23 Martin Schulze <teebaum@cvs.gnome.org>
+
+ * configure.ac: Disable typeof() compiler checks.
+ * sigc++/adaptors/bind.h.m4: Remove unnecessary
+ deduce_result_type<> template specializations.
+
+2003-10-20 Martin Schulze <teebaum@cvs.gnome.org>
+
+ * sigc++/adaptors/compose.h.m4:
+ Correct order of typedefs for good. (Patch from Jeff Franks.)
+
+1.9.9:
+
+2003-10-20 Martin Schulze <teebaum@cvs.gnome.org>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * configure.ac: Bump version number to 1.9.7.
+
+2003-09-03 Martin Schulze <teebaum@cvs.gnome.org>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * Update TODO.
+
+2003-08-27 Martin Schulze <teebaum@cvs.gnome.org>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * sigc++/trackable.{cc,h}: Add function trackable::clear().
+
+2003-06-24 Andreas Rottmann <rottmann@users.sourceforge.net>
+
+ * TODO: Minor tweaks.
+
+2003-06-23 Andreas Rottmann <rottmann@users.sourceforge.net>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * 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 <murrayc@usa.net>
+
+ * 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 <teebaum@cvs.gnome.org>
+
+ * sigc++/signal.h.m4: Fix documentation.
+ * sigc++/connection.h, sigc++/functor/slot.h.m4:
+ Document the whole thing.
+
+2003-05-29 Martin Schulze <teebaum@cvs.gnome.org>
+
+ * 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 <MHL.Schulze@t-online.de>
+
+ * TODO, configure.ac, Makefile.am, docs/*:
+ Add Doxygen framework.
+
+2003-04-06 Martin Schulze <MHL.Schulze@t-online.de>
+
+ * 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 <MHL.Schulze@t-online.de>
+
+ * Change "closure" to "slot" throughout sigc++2 (file names,
+ class names, member variables, documentation, etc.).
+
+2003-03-26 Martin Schulze <MHL.Schulze@t-online.de>
+
+ * TODO: Rewrite to reflect recent changes as well as recent discussions.
+
+2003-03-24 Martin Schulze <MHL.Schulze@t-online.de>
+
+ * 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 <MHL.Schulze@t-online.de>
+
+ * 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<T_functor>::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 <murrayc@usa.net>
+
+ * Added pgk-config file, from a mystery person in bug #108857
+
+2003-03-22 Martin Schulze <MHL.Schulze@t-online.de>
+
+ * 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 <MHL.Schulze@t-online.de>
+
+ * 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 <murrayc@usa.net>
+
+ * 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 <rottmann@users.sourceforge.net>
+
+ * 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 <MHL.Schulze@t-online.de>
+
+ * sigc++/connection.h: Add block() capability.
+
+2003-03-09 Martin Schulze <MHL.Schulze@t-online.de>
+
+ * 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 <MHL.Schulze@t-online.de>
+
+ * 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 <MHL.Schulze@t-online.de>
+
+ * 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 <MHL.Schulze@t-online.de>
+
+ * sigc++/trackable.cc: BUGFIX in trackable_dep_list::clear()
+
+2003-03-08 Andreas Rottmann <rottmann@users.sourceforge.net>
+
+ * 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 <MHL.Schulze@t-online.de>
+
+ * 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 <MHL.Schulze@t-online.de>
+
+ * 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 <MHL.Schulze@t-online.de>
+
+ * 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 <MHL.Schulze@t-online.de>
+
+ * 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 <MHL.Schulze@t-online.de>
+
+ * sigc++/visit_each.h: BUGFIX in template specialization
+ limit_derive_target<T_Target*,T_action>::with_type<false,T_type>:
+ Add non-const overloads for static void execute_() avoiding
+ compile time errors.
+
+2003-02-16 Martin Schulze <MHL.Schulze@t-online.de>
+
+ * tests/Makefile.am, tests/test_disconnect.cc:
+ Add testcase with a mixed connection & disconnection sequence.
+
+2003-02-16 Martin Schulze <MHL.Schulze@t-online.de>
+
+ * 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 <MHL.Schulze@t-online.de>
+
+ * 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 <murrayc@usa.net>
+
+ * 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 <murrayc@usa.net>
+
+ * Added Andreas Rottman's example.
+
+2003-01-22 Murray Cumming <murrayc@usa.net>
+
+ * Applied Andreas Rottman's make dist fixes.
+
+2003-01-14 Murray Cumming <murrayc@usa.net>
+
+ * Added whitespace to make the code more readable.
--- /dev/null
+# NMake Makefile for building libsigc++ on Windows using Visual Studio
+
+# The items below this line should not be changed, unless one is maintaining
+# the NMake Makefiles. Customizations can be done in the following NMake Makefile
+# portions (please see comments in the these files to see what can be customized):
+#
+# detectenv-msvc.mak
+# config-msvc.mak
+
+!include detectenv-msvc.mak
+
+# Include the Makefile portions with the source listings
+!include ..\sigc++\filelist.am
+
+# Include the Makefile portion that enables features based on user input
+!include config-msvc.mak
+
+!if "$(VALID_CFGSET)" == "TRUE"
+
+# We need Visual Studio 2013 or later
+!if $(VSVER) < 12
+VALID_MSC = FALSE
+!else
+VALID_MSC = TRUE
+!endif
+
+!if "$(VALID_MSC)" == "TRUE"
+
+!ifdef GENERATE_VERSIONED_FILES
+!include pkg-ver.mak
+DO_REAL_GEN = 1
+!endif
+
+all: $(LIBSIGC_LIB) examples all-build-info
+
+# Include the Makefile portion to convert the source and header lists
+# into the lists we need for compilation and introspection
+!include create-lists-msvc.mak
+
+examples: $(libsigc_examples)
+
+tests: $(libsigc_tests) all-build-info
+
+benchmark: all $(libsigc_benchmark) all-build-info
+
+# Include the build rules for sources, DLLs and executables
+!include generate-msvc.mak
+!include build-rules-msvc.mak
+
+!include install.mak
+
+!else # "$(VALID_MSC)" == "TRUE"
+all:
+ @echo You need Visual Studio 2013 or later.
+
+!endif # "$(VALID_MSC)" == "TRUE"
+
+!else # "$(VALID_CFGSET)" == "TRUE"
+all: help
+ @echo You need to specify a valid configuration, via
+ @echo CFG=release or CFG=debug
+!endif # "$(VALID_CFGSET)" == "TRUE"
+
+!include info-msvc.mak
--- /dev/null
+Instructions for building libsigc++ on Visual Studio
+====================================================
+Building the libsigc++ on Windows is now supported using Visual Studio
+versions 2013 or later in both 32-bit and 64-bit (x64) flavors,
+via NMake Makefiles. Due to C++-11 usage, Visual Studio 2012 or
+earlier is not supported.
+
+libsigc++ itself has no external dependencies, but building the
+benchmark test program will require an installation of the Boost
+C++ libraries.
+
+The following describes what items are built with the following
+targets:
+
+-all (or no target specified): The libsigc++ DLL and the example programs.
+-test: The libsigc++ DLL and the test programs.
+-benchmark: The libsigc++ DLL and the benchmark program.
+-prep-git-build: Prepare to build directly from a GIT checkout. You
+ will at least need PERL for this, and m4 if building from a
+ GIT checkout or when building after running the 'forceclean'
+ 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 provided to copy the
+built items in their appropriate locations under $(PREFIX), which is described below.
+
+A 'forceclean' target is also provided to cover the actions under the target 'clean',
+but also to remove any traces of the headers and sources that were generated. This
+may be useful if one wants to re-generate the sources and headers from the m4 templates.
+
+Invoke the build by issuing the command:
+nmake /f Makefile.vc CFG=[release|debug] [PREFIX=...] <option1=1 option2=1 ...>
+where:
+
+CFG: Required. Choose from a release or debug build. Note that
+ all builds generate a .pdb file for each .dll and .exe built--this refers
+ to the C/C++ runtime that the build uses.
+
+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 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 builds, and
+ $(X) is the short version of the Visual Studio used, as follows:
+ 2017: 15
+
+Explanation of options, set by <option>=1:
+------------------------------------------
+BOOST_DLL: When building the benchmark, link to a DLL build of the Boost
+ libraries. Required if your installation of the Boost libraries
+ are built as DLLs. Note that debug builds must link to debug
+ builds of Boost and release builds must link to releease builds
+ of Boost.
--- /dev/null
+# NMake Makefile portion for compilation rules
+# Items in here should not need to be edited unless
+# one is maintaining the NMake build files. The format
+# of NMake Makefiles here are different from the GNU
+# Makefiles. Please see the comments about these formats.
+
+# Inference rules for compiling the .obj files.
+# Used for libs and programs with more than a single source file.
+# Format is as follows
+# (all dirs must have a trailing '\'):
+#
+# {$(srcdir)}.$(srcext){$(destdir)}.obj::
+# $(CC)|$(CXX) $(cflags) /Fo$(destdir) /c @<<
+# $<
+# <<
+{..\sigc++\}.cc{vs$(VSVER)\$(CFG)\$(PLAT)\sigc\}.obj:
+ @for %f in ($(base_built_cc) $(base_built_h)) do @if not exist ..\sigc++\%f if not exist ..\untracked\sigc++\%f if not exist $(@D)\sigc++\%f $(MAKE) /f Makefile.vc CFG=$(CFG) generate-sources
+ @for %f in ($(functors_built_cc) $(functors_built_h)) do @if not exist ..\sigc++\functors\%f if not exist ..\untracked\sigc++\functors\%f if not exist $(@D)\sigc++\functors\%f $(MAKE) /f Makefile.vc CFG=$(CFG) generate-sources
+ @for %f in ($(adaptors_built_cc) $(adaptors_built_h)) do @if not exist ..\sigc++\adaptors\%f if not exist ..\untracked\sigc++\adaptors\%f if not exist $(@D)\sigc++\adaptors\%f $(MAKE) /f Makefile.vc CFG=$(CFG) generate-sources
+ @for %f in ($(lambda_built_cc) $(lambda_built_h)) do @if not exist ..\sigc++\adaptors\lambda\%f if not exist ..\untracked\sigc++\adaptors\lambda\%f if not exist $(@D)\sigc++\adaptors\lambda\%f $(MAKE) /f Makefile.vc CFG=$(CFG) generate-sources
+ @if not exist .\sigc++config.h if not exist ..\untracked\MSVC_NMake\sigc++config.h $(MAKE) /f Makefile.vc CFG=$(CFG) sigc++config.h
+ @if not exist $(@D)\ md $(@D)
+ $(CXX) $(LIBSIGCPP_CFLAGS) /Fo$(@D)\ /Fd$(@D)\ /c @<<
+$<
+<<
+
+{..\sigc++\adaptors\lambda\}.cc{vs$(VSVER)\$(CFG)\$(PLAT)\sigc\}.obj:
+ @for %f in ($(base_built_cc) $(base_built_h)) do @if not exist ..\sigc++\%f if not exist ..\untracked\sigc++\%f if not exist $(@D)\sigc++\%f $(MAKE) /f Makefile.vc CFG=$(CFG) generate-sources
+ @for %f in ($(functors_built_cc) $(functors_built_h)) do @if not exist ..\sigc++\functors\%f if not exist ..\untracked\sigc++\functors\%f if not exist $(@D)\sigc++\functors\%f $(MAKE) /f Makefile.vc CFG=$(CFG) generate-sources
+ @for %f in ($(adaptors_built_cc) $(adaptors_built_h)) do @if not exist ..\sigc++\adaptors\%f if not exist ..\untracked\sigc++\adaptors\%f if not exist $(@D)\sigc++\adaptors\%f $(MAKE) /f Makefile.vc CFG=$(CFG) generate-sources
+ @for %f in ($(lambda_built_cc) $(lambda_built_h)) do @if not exist ..\sigc++\adaptors\lambda\%f if not exist ..\untracked\sigc++\adaptors\lambda\%f if not exist $(@D)\sigc++\adaptors\lambda\%f $(MAKE) /f Makefile.vc CFG=$(CFG) generate-sources
+ @if not exist .\sigc++config.h if not exist ..\untracked\MSVC_NMake\sigc++config.h $(MAKE) /f Makefile.vc CFG=$(CFG) sigc++config.h
+ @if not exist $(@D)\ md $(@D)
+ $(CXX) $(LIBSIGCPP_CFLAGS) /Fo$(@D)\ /Fd$(@D)\ /c @<<
+$<
+<<
+
+{..\sigc++\functors\}.cc{vs$(VSVER)\$(CFG)\$(PLAT)\sigc\}.obj:
+ @for %f in ($(base_built_cc) $(base_built_h)) do @if not exist ..\sigc++\%f if not exist ..\untracked\sigc++\%f if not exist $(@D)\sigc++\%f $(MAKE) /f Makefile.vc CFG=$(CFG) generate-sources
+ @for %f in ($(functors_built_cc) $(functors_built_h)) do @if not exist ..\sigc++\functors\%f if not exist ..\untracked\sigc++\functors\%f if not exist $(@D)\sigc++\functors\%f $(MAKE) /f Makefile.vc CFG=$(CFG) generate-sources
+ @for %f in ($(adaptors_built_cc) $(adaptors_built_h)) do @if not exist ..\sigc++\adaptors\%f if not exist ..\untracked\sigc++\adaptors\%f if not exist $(@D)\sigc++\adaptors\%f $(MAKE) /f Makefile.vc CFG=$(CFG) generate-sources
+ @for %f in ($(lambda_built_cc) $(lambda_built_h)) do @if not exist ..\sigc++\adaptors\lambda\%f if not exist ..\untracked\sigc++\adaptors\lambda\%f if not exist $(@D)\sigc++\adaptors\lambda\%f $(MAKE) /f Makefile.vc CFG=$(CFG) generate-sources
+ @if not exist .\sigc++config.h if not exist ..\untracked\MSVC_NMake\sigc++config.h $(MAKE) /f Makefile.vc CFG=$(CFG) sigc++config.h
+ @if not exist $(@D)\ md $(@D)
+ $(CXX) $(LIBSIGCPP_CFLAGS) /Fo$(@D)\ /Fd$(@D)\ /c @<<
+$<
+<<
+
+{..\untracked\sigc++\adaptors\lambda\}.cc{vs$(VSVER)\$(CFG)\$(PLAT)\sigc\}.obj:
+ @for %f in ($(base_built_cc) $(base_built_h)) do @if not exist ..\sigc++\%f if not exist ..\untracked\sigc++\%f if not exist $(@D)\sigc++\%f $(MAKE) /f Makefile.vc CFG=$(CFG) generate-sources
+ @for %f in ($(functors_built_cc) $(functors_built_h)) do @if not exist ..\sigc++\functors\%f if not exist ..\untracked\sigc++\functors\%f if not exist $(@D)\sigc++\functors\%f $(MAKE) /f Makefile.vc CFG=$(CFG) generate-sources
+ @for %f in ($(adaptors_built_cc) $(adaptors_built_h)) do @if not exist ..\sigc++\adaptors\%f if not exist ..\untracked\sigc++\adaptors\%f if not exist $(@D)\sigc++\adaptors\%f $(MAKE) /f Makefile.vc CFG=$(CFG) generate-sources
+ @for %f in ($(lambda_built_cc) $(lambda_built_h)) do @if not exist ..\sigc++\adaptors\lambda\%f if not exist ..\untracked\sigc++\adaptors\lambda\%f if not exist $(@D)\sigc++\adaptors\lambda\%f $(MAKE) /f Makefile.vc CFG=$(CFG) generate-sources
+ @if not exist .\sigc++config.h if not exist ..\untracked\MSVC_NMake\sigc++config.h $(MAKE) /f Makefile.vc CFG=$(CFG) sigc++config.h
+ @if not exist $(@D)\ md $(@D)
+ $(CXX) $(LIBSIGCPP_CFLAGS) /Fo$(@D)\ /Fd$(@D)\ /c @<<
+$<
+<<
+
+{vs$(VSVER)\$(CFG)\$(PLAT)\sigc\sigc++\adaptors\lambda\}.cc{vs$(VSVER)\$(CFG)\$(PLAT)\sigc\}.obj:
+ @for %f in ($(base_built_cc) $(base_built_h)) do @if not exist ..\sigc++\%f if not exist ..\untracked\sigc++\%f if not exist $(@D)\sigc++\%f $(MAKE) /f Makefile.vc CFG=$(CFG) generate-sources
+ @for %f in ($(functors_built_cc) $(functors_built_h)) do @if not exist ..\sigc++\functors\%f if not exist ..\untracked\sigc++\functors\%f if not exist $(@D)\sigc++\functors\%f $(MAKE) /f Makefile.vc CFG=$(CFG) generate-sources
+ @for %f in ($(adaptors_built_cc) $(adaptors_built_h)) do @if not exist ..\sigc++\adaptors\%f if not exist ..\untracked\sigc++\adaptors\%f if not exist $(@D)\sigc++\adaptors\%f $(MAKE) /f Makefile.vc CFG=$(CFG) generate-sources
+ @for %f in ($(lambda_built_cc) $(lambda_built_h)) do @if not exist ..\sigc++\adaptors\lambda\%f if not exist ..\untracked\sigc++\adaptors\lambda\%f if not exist $(@D)\sigc++\adaptors\lambda\%f $(MAKE) /f Makefile.vc CFG=$(CFG) generate-sources
+ @if not exist .\sigc++config.h if not exist ..\untracked\MSVC_NMake\sigc++config.h $(MAKE) /f Makefile.vc CFG=$(CFG) sigc++config.h
+ $(CXX) $(LIBSIGCPP_CFLAGS) /Fo$(@D)\ /Fd$(@D)\ /c @<<
+$<
+<<
+
+# Rules for building .lib files
+$(LIBSIGC_LIB): $(LIBSIGC_DLL)
+
+{.}.rc{vs$(VSVER)\$(CFG)\$(PLAT)\sigc\}.res:
+ rc /fo$@ $<
+
+{..\untracked\MSVC_NMake\}.rc{vs$(VSVER)\$(CFG)\$(PLAT)\sigc\}.res:
+ rc /fo$@ $<
+
+# Rules for linking DLLs
+# Format is as follows (the mt command is needed for MSVC 2005/2008 builds):
+# $(dll_name_with_path): $(dependent_libs_files_objects_and_items)
+# link /DLL [$(linker_flags)] [$(dependent_libs)] [/def:$(def_file_if_used)] [/implib:$(lib_name_if_needed)] -out:$@ @<<
+# $(dependent_objects)
+# <<
+# @-if exist $@.manifest mt /manifest $@.manifest /outputresource:$@;2
+$(LIBSIGC_DLL): $(sigc_dll_OBJS)
+ link /DLL $(LDFLAGS) /implib:$(LIBSIGC_LIB) -out:$@ @<<
+$(sigc_dll_OBJS)
+<<
+ @-if exist $@.manifest mt /manifest $@.manifest /outputresource:$@;2
+
+# Rules for linking Executables
+# Format is as follows (the mt command is needed for MSVC 2005/2008 builds):
+# $(dll_name_with_path): $(dependent_libs_files_objects_and_items)
+# link [$(linker_flags)] [$(dependent_libs)] -out:$@ @<<
+# $(dependent_objects)
+# <<
+# @-if exist $@.manifest mt /manifest $@.manifest /outputresource:$@;1
+
+clean:
+ @-del /f /q vs$(VSVER)\$(CFG)\$(PLAT)\*.exe
+ @-del /f /q vs$(VSVER)\$(CFG)\$(PLAT)\*.dll
+ @-del /f /q vs$(VSVER)\$(CFG)\$(PLAT)\*.pdb
+ @-del /f /q vs$(VSVER)\$(CFG)\$(PLAT)\*.ilk
+ @-del /f /q vs$(VSVER)\$(CFG)\$(PLAT)\*.exp
+ @-del /f /q vs$(VSVER)\$(CFG)\$(PLAT)\*.lib
+ @-if exist vs$(VSVER)\$(CFG)\$(PLAT)\sigc-tests del /f /q vs$(VSVER)\$(CFG)\$(PLAT)\sigc-tests\*.obj
+ @-if exist vs$(VSVER)\$(CFG)\$(PLAT)\sigc-tests del /f /q vs$(VSVER)\$(CFG)\$(PLAT)\sigc-tests\*.pdb
+ @-del /f /q vs$(VSVER)\$(CFG)\$(PLAT)\sigc-ex\*.obj
+ @-del /f /q vs$(VSVER)\$(CFG)\$(PLAT)\sigc-ex\*.pdb
+ @-del /f /q vs$(VSVER)\$(CFG)\$(PLAT)\sigc\*.res
+ @-del /f /q vs$(VSVER)\$(CFG)\$(PLAT)\sigc\*.obj
+ @-del /f /q vs$(VSVER)\$(CFG)\$(PLAT)\sigc\*.pdb
+ @-if exist vs$(VSVER)\$(CFG)\$(PLAT)\sigc-tests rd vs$(VSVER)\$(CFG)\$(PLAT)\sigc-tests
+ @-rd vs$(VSVER)\$(CFG)\$(PLAT)\sigc-ex
+ @-for %d in ($(sigc_m4_srcdirs)) do @for %x in (cc h) do @if exist vs$(VSVER)\$(CFG)\$(PLAT)\sigc\sigc++\%d\ del /f /q vs$(VSVER)\$(CFG)\$(PLAT)\sigc\sigc++\%d\*.%x
+ @-for %x in (cc h) do @if exist vs$(VSVER)\$(CFG)\$(PLAT)\sigc\sigc++\ del /f /q vs$(VSVER)\$(CFG)\$(PLAT)\sigc\sigc++\*.%x
+ @-for %d in ($(sigc_m4_srcdirs)) do @rd vs$(VSVER)\$(CFG)\$(PLAT)\sigc\sigc++\%d
+ @-rd vs$(VSVER)\$(CFG)\$(PLAT)\sigc\sigc++
+ @-rd vs$(VSVER)\$(CFG)\$(PLAT)\sigc
+
+forceclean: clean
+ @-for %d in (. adaptors\lambda adaptors functors) do @for %t in (.. ..\untracked) do @for %x in (cc h) do @for %f in (..\sigc++\%d\macros\*.%x.m4) do @del %t\sigc++\%d\%~nf
--- /dev/null
+# NMake Makefile portion for enabling features for Windows builds
+
+# These are the base minimum libraries required for building libsigc++.
+BASE_INCLUDES = /I$(PREFIX)\include
+
+# Please do not change anything beneath this line unless maintaining the NMake Makefiles
+
+LIBSIGC_MAJOR_VERSION = 2
+LIBSIGC_MINOR_VERSION = 0
+
+!if "$(CFG)" == "debug" || "$(CFG)" == "Debug"
+DEBUG_SUFFIX = -d
+!else
+DEBUG_SUFFIX =
+!endif
+
+!ifndef M4
+M4 = m4
+!endif
+
+LIBSIGCPP_DEFINES = /DSIGC_BUILD /D_WINDLL
+
+SIGCPP_BASE_CFLAGS = \
+ /Ivs$(VSVER)\$(CFG)\$(PLAT)\sigc \
+ /I..\untracked /I.. /I..\untracked\MSVC_NMake /I. \
+ /EHsc $(CFLAGS)
+
+LIBSIGC_INT_SOURCES = $(sigc_sources_cc:/=\)
+LIBSIGC_INT_HDRS = $(sigc_public_h:/=\)
+
+SIGCPP_CFLAGS = $(SIGCPP_BASE_CFLAGS) $(CFLAGS)
+LIBSIGCPP_CFLAGS = $(SIGCPP_CFLAGS) $(LIBSIGCPP_DEFINES)
+
+# We build sigc-vc$(PDBVER)0-$(LIBSIGC_MAJOR_VERSION)_$(LIBSIGC_MINOR_VERSION).dll or
+# sigc-vc$(PDBVER)0d-$(LIBSIGC_MAJOR_VERSION)_$(LIBSIGC_MINOR_VERSION).dll at least
+
+!ifdef USE_MESON_LIBS
+LIBSIGC_LIBNAME = sigc-$(LIBSIGC_MAJOR_VERSION).$(LIBSIGC_MINOR_VERSION)
+LIBSIGC_DLLNAME = $(LIBSIGC_LIBNAME)-0
+!else
+LIBSIGC_LIBNAME = sigc-vc$(PDBVER)0$(DEBUG_SUFFIX)-$(LIBSIGC_MAJOR_VERSION)_$(LIBSIGC_MINOR_VERSION)
+LIBSIGC_DLLNAME = $(LIBSIGC_LIBNAME)
+!endif
+
+LIBSIGC_DLL = vs$(VSVER)\$(CFG)\$(PLAT)\$(LIBSIGC_DLLNAME).dll
+LIBSIGC_LIB = vs$(VSVER)\$(CFG)\$(PLAT)\$(LIBSIGC_LIBNAME).lib
+
+# Note that building the benchmark requires Boost!
+libsigc_bench = vs$(VSVER)\$(CFG)\$(PLAT)\libsigc++-benchmark.exe
+
+# If your Boost libraries are built as DLLs, use BOOST_DLL=1 in your NMake command line
+!ifdef BOOST_DLL
+SIGCPP_BENCHMARK_CFLAGS = $(SIGCPP_BASE_CFLAGS) /DBOOST_ALL_DYN_LINK
+!else
+SIGCPP_BENCHMARK_CFLAGS = $(SIGCPP_BASE_CFLAGS)
+!endif
--- /dev/null
+# Convert the source listing to object (.obj) listing in
+# another NMake Makefile module, include it, and clean it up.
+# This is a "fact-of-life" regarding NMake Makefiles...
+# This file does not need to be changed unless one is maintaining the NMake Makefiles
+
+# For those wanting to add things here:
+# To add a list, do the following:
+# # $(description_of_list)
+# if [call create-lists.bat header $(makefile_snippet_file) $(variable_name)]
+# endif
+#
+# if [call create-lists.bat file $(makefile_snippet_file) $(file_name)]
+# endif
+#
+# if [call create-lists.bat footer $(makefile_snippet_file)]
+# endif
+# ... (repeat the if [call ...] lines in the above order if needed)
+# !include $(makefile_snippet_file)
+#
+# (add the following after checking the entries in $(makefile_snippet_file) is correct)
+# (the batch script appends to $(makefile_snippet_file), you will need to clear the file unless the following line is added)
+#!if [del /f /q $(makefile_snippet_file)]
+#!endif
+
+# In order to obtain the .obj filename that is needed for NMake Makefiles to build DLLs/static LIBs or EXEs, do the following
+# instead when doing 'if [call create-lists.bat file $(makefile_snippet_file) $(file_name)]'
+# (repeat if there are multiple $(srcext)'s in $(source_list), ignore any headers):
+# !if [for %c in ($(source_list)) do @if "%~xc" == ".$(srcext)" @call create-lists.bat file $(makefile_snippet_file) $(intdir)\%~nc.obj]
+#
+# $(intdir)\%~nc.obj needs to correspond to the rules added in build-rules-msvc.mak
+# %~xc gives the file extension of a given file, %c in this case, so if %c is a.cc, %~xc means .cc
+# %~nc gives the file name of a given file without extension, %c in this case, so if %c is a.cc, %~nc means a
+
+NULL=
+
+# For libsigc++
+
+!if [call create-lists.bat header sigc.mak sigc_dll_OBJS]
+!endif
+
+!if [for %c in ($(sigc_sources_cc)) do @if "%~xc" == ".cc" @call create-lists.bat file sigc.mak vs^$(VSVER)\^$(CFG)\^$(PLAT)\sigc\%~nc.obj]
+!endif
+
+!if [@call create-lists.bat file sigc.mak vs^$(VSVER)\^$(CFG)\^$(PLAT)\sigc\sigc.res]
+!endif
+
+!if [call create-lists.bat footer sigc.mak]
+!endif
+
+!if [call create-lists.bat header sigc.mak sigc_m4_srcdirs]
+!endif
+
+!if [for %d in (adaptors\lambda adaptors functors) do @call create-lists.bat file sigc.mak %d]
+!endif
+
+!if [call create-lists.bat footer sigc.mak]
+!endif
+
+!if [for %d in (examples tests) do @call create-lists.bat header sigc.mak libsigc_%d & @(for %s in (..\%d\*.cc) do @if not "%~ns" == "testutilities" if not "%~ns" == "benchmark" call create-lists.bat file sigc.mak vs$(VSVER)\$(CFG)\$(PLAT)\%~ns.exe) & @call create-lists.bat footer sigc.mak]
+!endif
+
+!if [call create-lists.bat header sigc.mak libsigc_benchmark & @for %s in (..\tests\benchmark.cc) do @(call create-lists.bat file sigc.mak vs$(VSVER)\$(CFG)\$(PLAT)\%~ns.exe) & @call create-lists.bat footer sigc.mak]
+!endif
+
+!if [for %d in (examples tests) do @for %s in (..\%d\*.cc) do @if not "%~ns" == "benchmark" echo vs^$(VSVER)\^$(CFG)\^$(PLAT)\sigc-%d\%~ns.obj: %s>>sigc.mak & @echo. @if not exist ^$(@D)\ md ^$(@D)>>sigc.mak & @echo. ^$(CXX) ^$(SIGCPP_CFLAGS) /Fo^$(@D)\ /Fd^$(@D)\ ^$** /c>>sigc.mak & @echo.>>sigc.mak]
+!endif
+
+!if [for %s in (..\tests\benchmark.cc) do @echo vs^$(VSVER)\^$(CFG)\^$(PLAT)\sigc-tests\%~ns.obj: %s>>sigc.mak & @echo. @if not exist ^$(@D)\ md ^$(@D)>>sigc.mak & @echo. ^$(CXX) ^$(SIGCPP_BENCHMARK_CFLAGS) /Fo^$(@D)\ /Fd^$(@D)\ ^$** /c>>sigc.mak & @echo.>>sigc.mak]
+!endif
+
+!if [for %s in (..\examples\*.cc) do @echo vs^$(VSVER)\^$(CFG)\^$(PLAT)\%~ns.exe: ^$(LIBSIGC_LIB) vs^$(VSVER)\^$(CFG)\^$(PLAT)\sigc-examples\%~ns.obj>>sigc.mak & @echo. link ^$(LDFLAGS) ^$** /out:^$@>>sigc.mak & @echo.>>sigc.mak]
+!endif
+
+!if [for %s in (..\tests\*.cc) do @if not "%~ns" == "testutilities" echo vs^$(VSVER)\^$(CFG)\^$(PLAT)\%~ns.exe: ^$(LIBSIGC_LIB) vs^$(VSVER)\^$(CFG)\^$(PLAT)\sigc-tests\%~ns.obj vs^$(VSVER)\^$(CFG)\^$(PLAT)\sigc-tests\testutilities.obj>>sigc.mak & @echo. link ^$(LDFLAGS) ^$** /out:^$@>>sigc.mak & @echo.>>sigc.mak]
+!endif
+
+!include sigc.mak
+
+!if [del /f /q sigc.mak]
+!endif
--- /dev/null
+@echo off
+rem Simple .bat script for creating the NMake Makefile snippets.
+
+if not "%1" == "header" if not "%1" == "file" if not "%1" == "footer" goto :error_cmd
+if "%2" == "" goto error_no_destfile
+
+if "%1" == "header" goto :header
+if "%1" == "file" goto :addfile
+if "%1" == "footer" goto :footer
+
+:header
+if "%3" == "" goto error_var
+echo %3 = \>>%2
+goto done
+
+:addfile
+if "%3" == "" goto error_file
+echo. %3 \>>%2
+goto done
+
+:footer
+echo. $(NULL)>>%2
+echo.>>%2
+goto done
+
+:error_cmd
+echo Specified command '%1' was invalid. Valid commands are: header file footer.
+goto done
+
+:error_no_destfile
+echo Destination NMake snippet file must be specified
+goto done
+
+:error_var
+echo A name must be specified for using '%1'.
+goto done
+
+:error_file
+echo A file must be specified for using '%1'.
+goto done
+
+:done
\ No newline at end of file
--- /dev/null
+# Change this (or specify PREFIX= when invoking this NMake Makefile) if
+# necessary, so that the libs and headers of the dependent third-party
+# libraries can be located. For instance, if building from GLib's
+# included Visual Studio projects, this should be able to locate the GLib
+# build out-of-the-box if they were not moved. GLib's headers will be
+# found in $(GLIB_PREFIX)\include\glib-2.0 and
+# $(GLIB_PREFIX)\lib\glib-2.0\include and its import library will be found
+# in $(GLIB_PREFIX)\lib.
+
+!if "$(PREFIX)" == ""
+PREFIX = ..\..\vs$(VSVER)\$(PLAT)
+!endif
+
+# Location of the PERL interpreter, for running glib-mkenums. glib-mkenums
+# needs to be found in $(PREFIX)\bin. Using either a 32-bit or x64 PERL
+# interpreter are supported for either a 32-bit or x64 build.
+
+!if "$(PERL)" == ""
+PERL = perl
+!endif
+
+# Location of the Python interpreter, for building introspection. The complete set
+# of Python Modules for introspection (the giscanner Python scripts and the _giscanner.pyd
+# compiled module) needs to be found in $(PREFIX)\lib\gobject-introspection\giscanner, and
+# the g-ir-scanner Python script and g-ir-compiler utility program needs to be found
+# in $(PREFIX)\bin, together with any DLLs they will depend on, if those DLLs are not already
+# in your PATH.
+# Note that the Python interpreter and the introspection modules and utility progam must
+# correspond to the build type (i.e. 32-bit Release for 32-bit Release builds, and so on).
+#
+# For introspection, currently only Python 2.7.x is supported. This may change when Python 3.x
+# support is added upstream in gobject-introspection--when this happens, the _giscanner.pyd must
+# be the one that is built against the release series of Python that is used here.
+
+!if "$(PYTHON)" == ""
+PYTHON = python
+!endif
+
+# Location of the pkg-config utility program, for building introspection. It needs to be able
+# to find the pkg-config (.pc) files so that the correct libraries and headers for the needed libraries
+# can be located, using PKG_CONFIG_PATH. Using either a 32-bit or x64 pkg-config are supported for
+# either a 32-bit or x64 build.
+
+!if "$(PKG_CONFIG)" == ""
+PKG_CONFIG = pkg-config
+!endif
+
+# The items below this line should not be changed, unless one is maintaining
+# the NMake Makefiles. The exception is for the CFLAGS_ADD line(s) where one
+# could use his/her desired compiler optimization flags, if he/she knows what is
+# being done.
+
+# Check to see we are configured to build with MSVC (MSDEVDIR, MSVCDIR or
+# VCINSTALLDIR) or with the MS Platform SDK (MSSDK or WindowsSDKDir)
+!if !defined(VCINSTALLDIR) && !defined(WINDOWSSDKDIR)
+MSG = ^
+This Makefile is only for Visual Studio 2008 and later.^
+You need to ensure that the Visual Studio Environment is properly set up^
+before running this Makefile.
+!error $(MSG)
+!endif
+
+ERRNUL = 2>NUL
+_HASH=^#
+
+!if ![echo VCVERSION=_MSC_VER > vercl.x] \
+ && ![echo $(_HASH)if defined(_M_IX86) >> vercl.x] \
+ && ![echo PLAT=Win32 >> vercl.x] \
+ && ![echo $(_HASH)elif defined(_M_AMD64) >> vercl.x] \
+ && ![echo PLAT=x64 >> vercl.x] \
+ && ![echo $(_HASH)elif defined(_M_ARM64) >> vercl.x] \
+ && ![echo PLAT=arm64 >> vercl.x] \
+ && ![echo $(_HASH)endif >> vercl.x] \
+ && ![cl -nologo -TC -P vercl.x $(ERRNUL)]
+!include vercl.i
+!if ![echo VCVER= ^\> vercl.vc] \
+ && ![set /a $(VCVERSION) / 100 - 6 >> vercl.vc]
+!include vercl.vc
+!endif
+!endif
+!if ![del $(ERRNUL) /q/f vercl.x vercl.i vercl.vc]
+!endif
+
+!if $(VCVERSION) > 1499 && $(VCVERSION) < 1600
+VSVER = 9
+!elseif $(VCVERSION) > 1599 && $(VCVERSION) < 1700
+VSVER = 10
+!elseif $(VCVERSION) > 1699 && $(VCVERSION) < 1800
+VSVER = 11
+!elseif $(VCVERSION) > 1799 && $(VCVERSION) < 1900
+VSVER = 12
+!elseif $(VCVERSION) > 1899 && $(VCVERSION) < 1910
+VSVER = 14
+!elseif $(VCVERSION) > 1909 && $(VCVERSION) < 1920
+VSVER = 15
+!elseif $(VCVERSION) > 1919 && $(VCVERSION) < 1930
+VSVER = 16
+!elseif $(VCVERSION) > 1929 && $(VCVERSION) < 2000
+VSVER = 17
+!else
+VSVER = 0
+!endif
+
+!if "$(VSVER)" == "0"
+MSG = ^
+This NMake Makefile set supports Visual Studio^
+9 (2008) through 16 (2019). Your Visual Studio^
+version is not supported.
+!error $(MSG)
+!else
+!if $(VSVER) < 15
+PDBVER = $(VSVER)
+!else
+PDBVER = 14
+!endif
+!endif
+
+VALID_CFGSET = FALSE
+!if "$(CFG)" == "release" || "$(CFG)" == "Release" || "$(CFG)" == "debug" || "$(CFG)" == "Debug"
+VALID_CFGSET = TRUE
+!endif
+
+# One may change these items, but be sure to test
+# the resulting binaries
+!if "$(CFG)" == "release" || "$(CFG)" == "Release"
+CFLAGS_ADD = /MD /O2 /GL /MP
+!if "$(VSVER)" != "9"
+CFLAGS_ADD = $(CFLAGS_ADD) /d2Zi+
+!endif
+!else
+CFLAGS_ADD = /MDd /Od
+!endif
+
+!if "$(PLAT)" == "x64"
+LDFLAGS_ARCH = /machine:x64
+!elseif "$(PLAT)" == "arm64"
+LDFLAGS_ARCH = /machine:arm64
+!else
+LDFLAGS_ARCH = /machine:x86
+!endif
+
+!if "$(VALID_CFGSET)" == "TRUE"
+CFLAGS = $(CFLAGS_ADD) /W3 /Zi
+
+LDFLAGS_BASE = $(LDFLAGS_ARCH) /libpath:$(PREFIX)\lib /DEBUG
+
+!if "$(CFG)" == "debug" || "$(CFG)" == "Debug"
+ARFLAGS = $(LDFLAGS_ARCH)
+LDFLAGS = $(LDFLAGS_BASE)
+!else
+ARFLAGS = $(LDFLAGS_ARCH) /LTCG
+LDFLAGS = $(LDFLAGS_BASE) /LTCG /opt:ref
+!endif
+!endif
--- /dev/null
+## This file is part of libsigc++.
+
+msvc_nmake_data = \
+ build-rules-msvc.mak \
+ config-msvc.mak \
+ create-lists.bat \
+ create-lists-msvc.mak \
+ detectenv-msvc.mak \
+ generate-msvc.mak \
+ info-msvc.mak \
+ install.mak \
+ Makefile.vc \
+ README.txt \
+ sigc++config.h \
+ sigc.rc
--- /dev/null
+# NMake Makefile portion for code generation and
+# intermediate build directory creation
+# Items in here should not need to be edited unless
+# one is maintaining the NMake build files.
+
+# Create the versioned files
+
+prep-git-build: pkg-ver.mak generate-sources
+
+sigc.rc: ..\configure.ac sigc.rc.in
+ @if not "$(DO_REAL_GEN)" == "1" if exist pkg-ver.mak del pkg-ver.mak
+ @if not exist pkg-ver.mak $(MAKE) /f Makefile.vc CFG=$(CFG) pkg-ver.mak
+ @if "$(DO_REAL_GEN)" == "1" echo Generating $@...
+ @if "$(DO_REAL_GEN)" == "1" copy $@.in $@
+ @if "$(DO_REAL_GEN)" == "1" $(PERL) -pi.bak -e "s/\@SIGCXX_MAJOR_VERSION\@/$(PKG_MAJOR_VERSION)/g" $@
+ @if "$(DO_REAL_GEN)" == "1" $(PERL) -pi.bak -e "s/\@SIGCXX_MINOR_VERSION\@/$(PKG_MINOR_VERSION)/g" $@
+ @if "$(DO_REAL_GEN)" == "1" $(PERL) -pi.bak -e "s/\@SIGCXX_MICRO_VERSION\@/$(PKG_MICRO_VERSION)/g" $@
+ @if "$(DO_REAL_GEN)" == "1" $(PERL) -pi.bak -e "s/\@PACKAGE_VERSION\@/$(PKG_MAJOR_VERSION).$(PKG_MINOR_VERSION).$(PKG_MICRO_VERSION)/g" $@
+ @if "$(DO_REAL_GEN)" == "1" $(PERL) -pi.bak -e "s/\@SIGCXX_API_VERSION\@/$(LIBSIGC_MAJOR_VERSION).$(LIBSIGC_MINOR_VERSION)/g" $@
+ @if "$(DO_REAL_GEN)" == "1" del $@.bak
+
+# You may change SIGCXX_DISABLE_DEPRECATED if you know what you are doing
+sigc++config.h: ..\configure.ac ..\sigc++config.h.in
+ @if not "$(DO_REAL_GEN)" == "1" if exist pkg-ver.mak del pkg-ver.mak
+ @if not exist pkg-ver.mak $(MAKE) /f Makefile.vc CFG=$(CFG) pkg-ver.mak
+ @if "$(DO_REAL_GEN)" == "1" echo Generating $@...
+ @if "$(DO_REAL_GEN)" == "1" copy "..\$(@F).in" "$@"
+ @if "$(DO_REAL_GEN)" == "1" $(PERL) -pi.bak -e "s/\#undef SIGCXX_DISABLE_DEPRECATED/\/\* \#undef SIGCXX_DISABLE_DEPRECATED \*\//g" $@
+ @if "$(DO_REAL_GEN)" == "1" $(PERL) -pi.bak -e "s/\#undef SIGCXX_MAJOR_VERSION/\#define SIGCXX_MAJOR_VERSION $(PKG_MAJOR_VERSION)/g" $@
+ @if "$(DO_REAL_GEN)" == "1" $(PERL) -pi.bak -e "s/\#undef SIGCXX_MINOR_VERSION/\#define SIGCXX_MINOR_VERSION $(PKG_MINOR_VERSION)/g" $@
+ @if "$(DO_REAL_GEN)" == "1" $(PERL) -pi.bak -e "s/\#undef SIGCXX_MICRO_VERSION/\#define SIGCXX_MICRO_VERSION $(PKG_MICRO_VERSION)/g" $@
+ @if "$(DO_REAL_GEN)" == "1" del $@.bak
+
+pkg-ver.mak: ..\configure.ac
+ @echo Generating version info Makefile Snippet...
+ @$(PERL) -00 -ne "print if /AC_INIT\(/" $** | \
+ $(PERL) -pe "tr/, /\n/s" | \
+ $(PERL) -ne "print if 2 .. 2" | \
+ $(PERL) -ne "print /\[(.*)\]/" > ver.txt
+ @echo @echo off>pkg-ver.bat
+ @echo.>>pkg-ver.bat
+ @echo set /p sigc_ver=^<ver.txt>>pkg-ver.bat
+ @echo for /f "tokens=1,2,3 delims=." %%%%a IN ("%%sigc_ver%%") do (echo PKG_MAJOR_VERSION=%%%%a^& echo PKG_MINOR_VERSION=%%%%b^& echo PKG_MICRO_VERSION=%%%%c)^>$@>>pkg-ver.bat
+ @pkg-ver.bat
+ @del ver.txt pkg-ver.bat
+ $(MAKE) /f Makefile.vc CFG=$(CFG) GENERATE_VERSIONED_FILES=1 sigc.rc sigc++config.h
+
+generate-sources:
+ @for %f in ($(base_built_cc) $(base_built_h)) do @if not exist ..\sigc++\%f if not exist ..\untracked\sigc++\%f if not exist vs$(VSVER)\$(CFG)\$(PLAT)\sigc\sigc++\ md vs$(VSVER)\$(CFG)\$(PLAT)\sigc\sigc++
+ @for %d in ($(sigc_m4_srcdirs)) do @for %x in (cc h) do @for %f in (..\sigc++\%d\macros\*.%x.m4) do @if not exist ..\sigc++\%d\%~nf if not exist ..\untracked\sigc++\%d\%~nf if not exist vs$(VSVER)\$(CFG)\$(PLAT)\sigc\sigc++\%d\ md vs$(VSVER)\$(CFG)\$(PLAT)\sigc\sigc++\%d
+ @for %f in ($(base_built_cc) $(base_built_h)) do @if not exist ..\sigc++\%f if not exist ..\untracked\sigc++\%f if not exist vs$(VSVER)\$(CFG)\$(PLAT)\sigc\sigc++\%f @echo Generating vs$(VSVER)\$(CFG)\$(PLAT)\sigc\sigc++\%f... & $(M4) -I ../sigc++/macros ../sigc++/macros/%f.m4 >vs$(VSVER)\$(CFG)\$(PLAT)\sigc\sigc++\%f
+ @for %d in ($(sigc_m4_srcdirs:adaptors\lambda=)) do @for %x in (cc h) do @for %f in (..\sigc++\%d\macros\*.%x.m4) do @if not exist ..\sigc++\%d\%~nf if not exist ..\untracked\sigc++\%d\%~nf if not exist vs$(VSVER)\$(CFG)\$(PLAT)\sigc\sigc++\%d\%~nf @echo Generating vs$(VSVER)\$(CFG)\$(PLAT)\sigc\sigc++\%d\%~nf... & $(M4) -I ../sigc++/%d/macros -I ../sigc++/macros ../sigc++/%d/macros/%~nxf >vs$(VSVER)\$(CFG)\$(PLAT)\sigc\sigc++\%d\%~nf
+ @for %x in (cc h) do @for %f in (..\sigc++\adaptors\lambda\macros\*.%x.m4) do @if not exist ..\sigc++\adaptors\lambda\%~nf if not exist ..\untracked\sigc++\adaptors\lambda\%~nf if not exist vs$(VSVER)\$(CFG)\$(PLAT)\sigc\sigc++\adaptors\lambda\%~nf @echo Generating vs$(VSVER)\$(CFG)\$(PLAT)\sigc\sigc++\adaptors\lambda\%~nf... & $(M4) -I ../sigc++/adaptors/lambda/macros -I ../sigc++/macros ../sigc++/adaptors/lambda/macros/%~nxf >vs$(VSVER)\$(CFG)\$(PLAT)\sigc\sigc++\adaptors\lambda\%~nf
--- /dev/null
+# NMake Makefile portion for displaying config info
+
+all-build-info:
+ @echo.
+ @echo ----------
+ @echo Build info
+ @echo ---------
+ @echo Build Type: $(CFG)
+
+help:
+ @echo.
+ @echo ==============================
+ @echo Building libsigc++ Using NMake
+ @echo ==============================
+ @echo nmake /f Makefile.vc CFG=[release^|debug] ^<PREFIX=PATH^>
+ @echo.
+ @echo Where:
+ @echo ------
+ @echo CFG: Required, use CFG=release for an optimized build and CFG=debug
+ @echo for a debug build. PDB files are generated for all builds.
+ @echo.
+ @echo PREFIX: Optional, the path where dependent libraries and tools may be
+ @echo found, default is ^$(srcrootdir)\..\vs^$(short_vs_ver)\^$(platform),
+ @echo where ^$(short_vs_ver) is 12 for VS 2013 and 14 for VS 2015 and so on;
+ @echo and ^$(platform) is Win32 for 32-bit builds and x64 for x64 builds.
+ @echo.
+ @echo ======
+ @echo A 'clean' target is supported to remove all generated files, intermediate
+ @echo object files and binaries for the specified configuration.
+ @echo.
+ @echo An 'install' target is supported to copy the build (DLLs, LIBs, along with
+ @echo the header files) to appropriate locations under ^$(PREFIX).
+ @echo.
+ @echo A 'tests' target is supported to build the test programs, and a 'benchmark'
+ @echo target is supported to build the benchmarking program. Note that the
+ @echo benchmarking program requires the Boost C++ libraries to build, and you need
+ @echo to pass in BOOST_DLL=1 to the NMake command line if your Boost libraries are
+ @echo built as DLLs.
+ @echo ======
+ @echo.
--- /dev/null
+# NMake Makefile snippet for copying the built libraries, utilities and headers to
+# a path under $(PREFIX).
+
+install: all
+ @if not exist $(PREFIX)\bin\ md $(PREFIX)\bin
+ @if not exist $(PREFIX)\lib\sigc++-$(LIBSIGC_MAJOR_VERSION).$(LIBSIGC_MINOR_VERSION)\include\ md $(PREFIX)\lib\sigc++-$(LIBSIGC_MAJOR_VERSION).$(LIBSIGC_MINOR_VERSION)\include
+ @if not exist $(PREFIX)\include\sigc++-$(LIBSIGC_MAJOR_VERSION).$(LIBSIGC_MINOR_VERSION)\sigc++\adaptors\lambda\ @md $(PREFIX)\include\sigc++-$(LIBSIGC_MAJOR_VERSION).$(LIBSIGC_MINOR_VERSION)\sigc++\adaptors\lambda
+ @if not exist $(PREFIX)\include\sigc++-$(LIBSIGC_MAJOR_VERSION).$(LIBSIGC_MINOR_VERSION)\sigc++\functors\ @md $(PREFIX)\include\sigc++-$(LIBSIGC_MAJOR_VERSION).$(LIBSIGC_MINOR_VERSION)\sigc++\functors
+ @if not exist $(PREFIX)\include\sigc++-$(LIBSIGC_MAJOR_VERSION).$(LIBSIGC_MINOR_VERSION)\sigc++\tuple-utils\ @md $(PREFIX)\include\sigc++-$(LIBSIGC_MAJOR_VERSION).$(LIBSIGC_MINOR_VERSION)\sigc++\tuple-utils
+ @copy /b vs$(VSVER)\$(CFG)\$(PLAT)\$(LIBSIGC_LIBNAME).dll "$(PREFIX)\bin"
+ @copy /b vs$(VSVER)\$(CFG)\$(PLAT)\$(LIBSIGC_LIBNAME).pdb "$(PREFIX)\bin"
+ @copy /b vs$(VSVER)\$(CFG)\$(PLAT)\$(LIBSIGC_LIBNAME).lib "$(PREFIX)\lib"
+ @copy "..\sigc++\sigc++.h" "$(PREFIX)\include\sigc++-$(LIBSIGC_MAJOR_VERSION).$(LIBSIGC_MINOR_VERSION)\sigc++\"
+ @for %h in ($(LIBSIGC_INT_HDRS)) do @copy "..\sigc++\%h" "$(PREFIX)\include\sigc++-$(LIBSIGC_MAJOR_VERSION).$(LIBSIGC_MINOR_VERSION)\sigc++\%h"
+ @for %d in (..\sigc++ ..\untracked\sigc++ vs$(VSVER)\$(CFG)\$(PLAT)\sigc\sigc++) do @(for %h in ($(base_built_h)) do @if exist %d\%h copy "%d\%h" "$(PREFIX)\include\sigc++-$(LIBSIGC_MAJOR_VERSION).$(LIBSIGC_MINOR_VERSION)\sigc++\%h")
+ @for %d in (..\sigc++ ..\untracked\sigc++ vs$(VSVER)\$(CFG)\$(PLAT)\sigc\sigc++) do @(for %h in ($(functors_built_h)) do @if exist %d\functors\%h copy "%d\functors\%h" "$(PREFIX)\include\sigc++-$(LIBSIGC_MAJOR_VERSION).$(LIBSIGC_MINOR_VERSION)\sigc++\functors\%h")
+ @for %d in (..\sigc++ ..\untracked\sigc++ vs$(VSVER)\$(CFG)\$(PLAT)\sigc\sigc++) do @(for %h in ($(adaptors_built_h)) do @if exist %d\adaptors\%h copy "%d\adaptors\%h" "$(PREFIX)\include\sigc++-$(LIBSIGC_MAJOR_VERSION).$(LIBSIGC_MINOR_VERSION)\sigc++\adaptors\%h")
+ @for %d in (..\sigc++ ..\untracked\sigc++ vs$(VSVER)\$(CFG)\$(PLAT)\sigc\sigc++) do @(for %h in ($(lambda_built_h)) do @if exist %d\adaptors\lambda\%h copy "%d\adaptors\lambda\%h" "$(PREFIX)\include\sigc++-$(LIBSIGC_MAJOR_VERSION).$(LIBSIGC_MINOR_VERSION)\sigc++\adaptors\lambda\%h")
+ @if exist sigc++config.h copy "sigc++config.h" "$(PREFIX)\lib\sigc++-$(LIBSIGC_MAJOR_VERSION).$(LIBSIGC_MINOR_VERSION)\include\"
+ @if exist ..\untracked\MSVC_NMake\sigc++config.h copy "..\untracked\MSVC_NMake\sigc++config.h" "$(PREFIX)\lib\sigc++-$(LIBSIGC_MAJOR_VERSION).$(LIBSIGC_MINOR_VERSION)\include\"
--- /dev/null
+# MSVC_NMake
+
+# Input: pkg_conf_data, sigcxxconfig_h, project_build_root, python3,
+# can_add_dist_script
+# Output: sigc_rc
+
+sigc_rc = configure_file(
+ input: 'sigc.rc.in',
+ output: '@BASENAME@',
+ configuration: pkg_conf_data,
+)
+
+# Copy the generated configuration header into the MSVC project directory.
+configure_file(
+ input: sigcxxconfig_h,
+ output: 'sigc++config.h',
+ copy: true,
+)
+
+untracked_msvc_nmake = 'untracked' / 'MSVC_NMake'
+handle_built_files = project_source_root / 'tools' / 'handle-built-files.py'
+
+if can_add_dist_script
+ # Distribute built files.
+ meson.add_dist_script(
+ python3, handle_built_files, 'dist_gen_msvc_files',
+ meson.current_build_dir(),
+ untracked_msvc_nmake,
+ project_build_root / 'sigc++config.h',
+ meson.current_build_dir() / 'sigc.rc',
+ )
+endif
--- /dev/null
+
+#include <winver.h>
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION @SIGCXX_MAJOR_VERSION@,@SIGCXX_MINOR_VERSION@,@SIGCXX_MICRO_VERSION@,1
+ PRODUCTVERSION @SIGCXX_MAJOR_VERSION@,@SIGCXX_MINOR_VERSION@,@SIGCXX_MICRO_VERSION@,1
+ FILEFLAGSMASK 0
+ FILEFLAGS 0x0L
+ FILEOS VOS__WINDOWS32
+ FILETYPE VFT_DLL
+ FILESUBTYPE VFT2_UNKNOWN
+BEGIN
+ BLOCK "StringFileInfo"
+ BEGIN
+ BLOCK "040904b0"
+ BEGIN
+ VALUE "CompanyName", "The libsigc++ development team (see AUTHORS)"
+ VALUE "FileDescription", "The Typesafe Callback Framework for C++"
+ VALUE "FileVersion", "@PACKAGE_VERSION@"
+ VALUE "LegalCopyright", "Distribution is under the LGPL (see COPYING)"
+ VALUE "OriginalFilename", "sigc-@SIGCXX_API_VERSION@.dll"
+ VALUE "ProductName", "libsigc++"
+ VALUE "ProductVersion", "@PACKAGE_VERSION@"
+ END
+ END
+ BLOCK "VarFileInfo"
+ BEGIN
+ VALUE "Translation", 0x409, 1200
+ END
+END
--- /dev/null
+## Copyright (c) 2009 Openismus GmbH <http://www.openismus.com/>
+##
+## This file is part of libsigc++.
+##
+## libsigc++ 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.
+##
+## libsigc++ 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 <http://www.gnu.org/licenses/>.
+
+ACLOCAL_AMFLAGS = -I build ${ACLOCAL_FLAGS}
+
+if ENABLE_DOCUMENTATION
+doc_subdirs = docs
+else
+doc_subdirs =
+endif
+SUBDIRS = sigc++ tests examples $(doc_subdirs)
+
+sigc_configdir = $(libdir)/$(SIGCXX_MODULE_NAME)/include
+nodist_sigc_config_HEADERS = sigc++config.h
+
+pkgconfigdir = $(libdir)/pkgconfig
+nodist_pkgconfig_DATA = $(SIGCXX_MODULE_NAME).pc
+noinst_DATA = $(SIGCXX_MODULE_NAME)-uninstalled.pc
+
+dist_noinst_SCRIPTS = autogen.sh
+
+include $(srcdir)/MSVC_NMake/filelist.am
+
+dist_noinst_DATA = $(addprefix MSVC_NMake/,$(msvc_nmake_data))
+
+DISTCLEANFILES = MSVC_NMake/sigc++config.h
+
+# Distribute files needed when building libsigc++ with meson.
+EXTRA_DIST = \
+ meson.build \
+ meson_options.txt \
+ sigc++config.h.meson \
+ MSVC_NMake/meson.build \
+ docs/manual/can_use_xmllint.xml \
+ docs/manual/meson.build \
+ docs/reference/meson.build \
+ examples/meson.build \
+ sigc++/meson.build \
+ subprojects/mm-common.wrap \
+ tests/meson.build \
+ tools/handle-built-files.py \
+ tools/tutorial-custom-cmd.py \
+ tools/gcc_template_specialization_operator_overload.cc \
+ tools/have_sun_reverse_iterator.cc \
+ tools/msvc_template_specialization_operator_overload.cc \
+ tools/pragma_push_pop_macro.cc \
+ untracked/README
+
+# Optional: auto-generate the ChangeLog file from the git log on make dist
+include $(top_srcdir)/build/dist-changelog.am
--- /dev/null
+2.10.8 (stable)
+
+Build:
+* Meson build: Perl is not required by new versions of mm-common
+ (Kjell Ahlstedt)
+* NMake Makefiles: Support building with VS2022
+ (Chun-wei Fan)
+
+Documentation:
+* Upgrade the manual from DocBook 4.1 to DocBook 5.0
+ (Kjell Ahlstedt)
+
+
+2.10.7 (stable)
+
+Meson build:
+* Make it possible to use sigc++ as a subproject
+ (Kjell Ahlstedt)
+* Fix dependency on files generated from .h.m4 files
+ (Kjell Ahlstedt)
+* No implicit_include_directories
+ (Kjell Ahlstedt)
+* Make quiet installations possible
+ (Kjell Ahlstedt)
+* Fix build as subproject without building documentation
+ (Kjell Ahlstedt) Issue #71 (Xavier Claessens)
+
+Documentation:
+* Links to *.gnome.org refer to sigc++-2.0 and gtkmm-3.0 versions
+ instead of latest versions
+ (Kjell Ahlstedt)
+
+
+2.10.6 (stable)
+
+Build:
+* Meson build: Fix versioning on macOS
+ (Tom Schoonjans) Pull request #65
+
+Documentation:
+* sigc++/sigc++.h: Describe how to use libsigc++ with Meson
+ (Kjell Ahlstedt)
+* Update links to the web page, now at
+ libsigcplusplus.github.io/libsigcplusplus
+ (Kjell Ahlstedt)
+
+
+2.10.4 (stable)
+
+Build:
+* Meson build: Set default value of the 'warnings' option to 'min'
+ (Kjell Ahlstedt)
+* NMake Makefiles: Several improvements
+ (Chun-Wei Fan) Pull request #58
+* docs/reference/: Update for Doxygen >= 1.8.16
+ (Kjell Ahlstedt)
+
+Documentation:
+* docs/manual/libsigc_manual.xml: Update signal and slot syntax
+ (Kjell Ahlstedt) Issue #59 (Denis Washington)
+
+The tarball for 2.10.4 has been created with 'meson dist'.
+If you build with Autotools from the tarball, please read the relevant
+part of README.
+
+
+2.10.3 (stable)
+
+Build:
+* Add Meson build, alongside the existing Autotools build.
+ (Kjell Ahlstedt, Chun-Wei Fan) Pull request #47, #50
+* Improve MSVC builds on Windows
+ (Chun-Wei Fan) Pull request #50
+* meson.build: Check if .git is a directory or file
+ (Kjell Ahlstedt) Merge request pangomm!8 (Ting-Wei Lan)
+* docs/reference/meson.build: Check if perl is found
+ (Kjell Ahlstedt) Issue #53 (Rasmus Thomsen)
+* README: Describe building with Meson and Autotools
+ (Kjell Ahlstedt)
+
+Tests:
+* Make test_track_obj.cc compile with clang++
+ (Kjell Ahlstedt)
+
+
+2.10.2: (stable)
+
+This release is identical to 2.10.1, except for:
+* Reference docs generated by Doxygen 1.8.11.
+ Hopefully it will show up at
+ https://developer.gnome.org/libsigc++/stable/
+
+
+2.10.1: (stable)
+
+* signal_impl::clear(): Don't clear the slot list during signal emission,
+ to prevent a segfault. And add a test for this.
+ (Kjell Ahlstedt) Bug #784550 (Andrejs Hanins)
+* slot_base::set_parent(): Create a dummy slot_rep if necessary
+ (Kjell Ahlstedt) Bug #167714 (Gerald Britton)
+* Avoid compiler warnings from function pointer conversions
+ (Kjell Ahlstedt) Issue #1 (sharkcz)
+ (Kjell Ahlstedt) Issue #8 (db0451)
+
+Build:
+* Make --disable-benchmark work.
+ (Christophe Lermytte) Bug #774732
+* Replace the Visual Studio project files with MSVC NMake project files
+ Add MSVC_NMake/README.txt for Visual Studio builds
+ (Chun-wei Fan) Pull request #11
+
+Documentation:
+* signal_base: Warn against deletion during emission
+ (Kjell Ahlstedt) Bug #167714 (Gerald Britton)
+* Update links in README, configure.ac, libsigcplusplus.doap
+ (Kjell Ahlstedt)
+
+2.10.0 (stable):
+
+* Build: Fix silent builds.
+ (Kjell Ahlstedt) Bug #768797
+
+2.9.3 (unstable):
+
+* signal:
+ Deprecate slots().
+ Please tell us if you really need this.
+ (Murray Cumming)
+ Deprecate emit_reverse().
+ Please tell us if you really need this.
+ (Murray Cumming)
+* Benchmark: Update it and use boost::timer, and actually build it,
+ but not built by default.
+ (Murray Cumming)
+
+Build:
+* Fix the build on MSVC++ 2013 and 2015.
+ (Chun-wei Fan) Bug #767777
+
+
+2.9.2 (unstable):
+
+* Minor documentation improvements.
+ (Murray Cumming)
+* Some more minor uses of C++11 syntax.
+ (Murray Cumming)
+
+
+2.9.1 (unstable):
+
+* slot: Allow sigc::slot<R(Args...)> syntax, like std::function,
+ deprecating the sigc::slot<R, Args...> syntax.
+ (Murray Cumming, Kjell Ahlstedt) Bug #763393
+* signal: Allow sigc::signal<R(Args...)> syntax, like std::function,
+ deprecating the sigc::signal<R, Args...> syntax.
+ (Murray Cumming, Kjell Ahlstedt) Bug #763393
+
+
+2.8.0 (stable):
+
+* Documentation: Mention use with CMake.
+
+2.7.2 (unstable):
+
+* Deprecate sigc::ref() and sigc::reference_wrapper(),
+ adding support instead for std::ref(), std::cref(),
+ and std::reference_wrapper().
+ (Murray Cumming)
+* mem_fun(): Deprecate mem_fun(pointer, func).
+ Leaving just mem_fun(reference, func).
+ Please let us know if you disagree strongly with this.
+ (Murray Cumming) Bug #763215
+* Make all operator bool() explicit. (A C++11 feature.)
+ (Murray Cumming)
+* Build: Remove some now-unnecessary configure checks.
+ But please let us know if this causes problems for you.
+ (Murray Cumming) Bug #762065 (Kjell Ahlstedt)
+* Build: Update MSVC project.
+ (Chun-wei Fan)
+* Documentation: Improve the documentation of mem_fun(), making it clear that
+ mem_fun() does not return a slot.
+ (Kjell Ahlstedt)
+
+2.7.1 (unstable):
+
+* signal: Add a moving connect() method, taking an rvalue reference
+ to a slot.
+ (Kjell Ahlstedt) Bug #756484
+* can_deduce_result_type_with_decltype: Rename the check() methods to
+ checksize(). check() is a preprocessor macro in Mac OS X.
+ (Kjell Ahlstedt) Bug #759315 (David Otto)
+* Temporarily undefine the nil macro, if it's defined.
+ nil is a preprocessor macro in Objective-C++ and Mac OS X.
+ (Kjell Ahlstedt) Bug #695235
+* Correct the mem_functor<> declarations.
+ Murray Cumming
+
+2.6.2 (stable):
+
+* slot: Handle auto-disconnection when a slot contains a slot
+ (Kjell Ahlstedt) Bug #755003 (Ryan Beasley)
+* slot and signal: Correct move constructors and move assignments.
+ (Kjell Ahlstedt) Bug #756484.
+* trackable, slot_base, signal_base, connection: Add some noexcept specs
+ (Kjell Ahlstedt) Bug #756484.
+* trackable, slot, signal: Remove noexcept from move operations.
+ (Kjell Ahlstedt) Bug #756484.
+* slot and signal: Add missing move constructors and move assignments
+ (Kjell Ahlstedt) Bug #756484.
+* signal_impl: =delete copy and move operations.
+ (Murray Cumming, Kjell Ahlstedt) Bug #756484
+* typed_slot_rep: =delete unimplemented copy and move operations.
+ (Murray Cumming, Kjell Ahlstedt) Bug #756484
+* slot_rep: =delete copy and move operations.
+ (Murray Cumming, Kjell Ahlstedt) Bug #756484
+
+
+2.6.1 (stable):
+
+* Add back deprecated adaptors/lambda API to avoid an unintented ABI break.
+ (Kjell Ahlstedt) Bug #755550 (Michael Biebl)
+* sigc::trackable: Move operations: Don't move the callback list
+ (Kjell Ahlstedt) Bug #755393 (Tom Schoonjans)
+
+
+2.6.0 (stable):
+
+* C++11: deduce_result_type: Simplify with C++11 variadic template.
+ (Murray Cumming, Marcin Kolny) Bug #753612
+* Fix the build with MSVC.
+ (Chun-wei Fan) Bug #754082
+* Update the website.
+ (Kjell Ahlstedt)
+
+
+2.5.4 (unstable):
+
+* slot_base::operator=(const &): Copy the blocked too,
+ so the destionation is blocked if the source is blocked,
+ regardless of whether the destionation was previously
+ blocked, because this seems to be what we should expect.
+ (Murray Cumming)
+* C++11: slot_base, slot*, signal_base, signal*, trackable:
+ Add move operations.
+ (Murray Cumming)
+* Update MSVC Projects, requiring at least MSVC++ .Net 2013
+ for C++11 support.
+ (Chun-wei Fan)
+
+
+2.5.3 (unstable):
+
+* Use C++11 "using" aliases to simplify code that uses type traits.
+ (Murray Cumming) Bug #753580
+
+
+2.5.2 (unstable):
+
+* Remove useless headers:
+ sigc++/class_slot.h
+ sigc++/hide.h
+ sigc++/method_slot.h
+ sigc++/object.h
+ sigc++/object_slot.h
+ sigc++/retype.h
+ Some of these still have equivalents in sigc++/adaptors/
+ (Kjell Ahlstedt, Murray Cumming) Bug #752560
+* C++11: Replace deprecated std::auto_ptr by std::unique_ptr.
+ (Kjell Ahlstedt)
+* C++11: Use std::is_base_of<> instead of our sigc::is_base_and_derived<>,
+ removing sigc::is_base_and_derived<>.
+ (Kjell Ahlstedt, Murray Cumming) Bug #752560
+* C++11: Use of range-based for loops.
+ (Murray Cumming)
+* C++11: Use of the auto keyword.
+ (Murray Cumming)
+* C++11: Use of nullptr instead of 0.
+ (Murray Cumming)
+* sigc++/slot.h: Use a regular .h file instead of generating it
+ from an .m4 file. Bug #752560
+ (Kjell Ahlstedt)
+* Visual Studio Builds: Move 2010 Projects to 2012 to support C++11.
+ (Chun-wei Fan)
+* Use -Wformat-security and -Wshadow with --enable-warnings=fatal.
+ (Murray Cumming)
+
+
+2.5.1 (unstable):
+
+* Use (and require) C++11
+ (Kjell Ahlstedt)
+* Using C++11 lambda functions to create sigc::slots:
+ Avoid the need for SIGC_FUNCTORS_DEDUCE_RESULT_TYPE_WITH_DECLTYPE.
+ (Kjell Ahlstedt)
+* Remove the already-deprecated sigc::lambda (and sigc::group) API.
+ This is an API change but should not be an ABI change, so it should
+ only affect you when rebuilding applications, if you use this API.
+ (Murray Cumming, Kjell Ahlstedt)
+
+
+2.4.1 (stable):
+
+* A slot's functor is destroyed when an empty slot is assigned to the slot.
+ (Kjell Ahlstedt) Bug #738602 (James Lin)
+* test_disconnect_during_emit tests that the slot is really disconnected
+ during signal emission.
+ (Kjell Ahlstedt)
+
+2.4.0 (stable):
+
+Note: API/ABI is the same as in release 2.3.2. Compared to stable
+releases 2.2.x, the API has been broken regarding visit_each() functions.
+See the NEWS entry for libsigc++ 2.3.2.
+
+* Fix the test_lambda test case for MS Visual C++ 2013 and other
+ C++11-compliant compilers.
+ (Kjell Ahlstedt) Bug #734368 (Ryan Beasley)
+* Add a missing #include in limit_reference.h.
+ (Kjell Ahlstedt)
+* Documentation:
+ - Use doxygen-extra.css from the mm-common package.
+ Requires mm-common 0.9.7 when configured to use maintainer-mode.
+ (Kjell Ahlstedt)
+
+2.3.2 (unstable):
+
+Note: The implementation of bug #724496 breaks API for some users,
+but it does not break ABI.
+Only users who have added their own visit_each() overloads are affected by
+the API break. Their programs will still compile, but there will be run-time
+errors, if they rely on auto-disconnection of slots.
+Updated instructions for users who implement their own adaptors are found
+in the description of sigc::adapts<>.
+
+* Replace visit_each() overloads by struct visitor<>.
+ Add the test_visit_each test case.
+ (Ryan Beasley, Kjell Ahlstedt) Bug #724496
+* signal_impl::notify(): Don't delete signal_impl during erase().
+ (Kjell Ahlstedt) Bug #564005 (Alexander Shaduri)
+* Fix 'make check' with clang++ 3.4 and --enable-warnings=fatal
+ (Kjell Ahlstedt) Bug #724496 (Ryan Beasley)
+* Fix test_cpp11_lambda for gcc 4.8
+ (Kjell Ahlstedt)
+* Speed up disconnection of slots.
+ (Kjell Ahlstedt) Bug #167714 (Neal E. Coombes)
+* Auto-generate the ChangeLog from the git log for 'make dist'.
+ (José Alburquerque)
+* Don't use __file__ in the FIREWALL m4 macro.
+ (Kjell Ahlstedt) Bug #699168 (John Ralls)
+* Add the track_obj() adaptor and test_track_obj test case.
+ Deprecate libsigc++ lambdas, sigc::group() and sigc::var().
+ Use C++11 lambda expressions instead.
+ (Kjell Ahlstedt) Bug #672555
+* Documentation:
+ - Emphasize that signals are reference counted.
+ (Kjell Ahlstedt) Bug #611941 (Jonathon Jongsma)
+ - Mention std::function<> and std::bind() where appropriate.
+ (Kjell Ahlstedt, Chris Vine)
+ - Use DOXYGEN_SHOULD_SKIP_THIS consistently to exclude internal
+ functions from the reference documentation.
+ (Kjell Ahlstedt)
+* Windows:
+ - Enable C++11 lambda expressions with MS Visual Studio 2012 and later
+ (Ryan Beasley) Bug #733752
+ - Update MSVC_Net2010
+ (Kjell Ahlstedt) Bug #724496 (Ryan Beasley)
+
+2.3.1 (unstable):
+
+* signal_base: Add blocked(), block(), unblock().
+ (Kjell Ahlstedt) Bug #153780
+
+2.2.11 (stable):
+
+* Fix comma operator in libsigc++ lambda expressions.
+ Andris Pavenis) Bug #342911
+* Added SIGC_FUNCTORS_DEDUCE_RESULT_TYPE_WITH_DECLTYPE.
+ This allows most uses of libsigc++'s lambda expressions to be
+ replaced by standard C++11 lambda expressions.
+ (Kjell Ahlstedt) Bug #672555.
+ Thanks to Chow Loong Jin, who posted similar code on libsigc-list.
+* Use std::size_t and std::ptrdiff_t instead
+ (Kjell Ahlstedt)
+* Fix 'make check' with gcc 4.7.
+ (Kjell Ahlstedt)
+* Enable test_lambda in 'make check'.
+ (Kjell Ahlstedt) Bug #669128.
+
+
+2.2.10:
+
+* slot_rep: Avoid access to deleted object in notify(),
+ and test case.
+ (Kjell Ahlstedt ) Bug #564005 (Alexander Shaduri)
+* Mention visit_each() in the documentation of sigc::adapts.
+ (Thomas Rydzynski)
+
+2.2.9:
+
+* trackable: Avoid calling the same callback function twice, fixing some
+ memory corruption.
+ (Kjell Ahlstedt) Bug #589202
+* Minor documentation corrections.
+ (David King)
+* Fix the build with GCC 4.6
+ (Kalev Lember)
+* Windows build fixes for MSVC++ .Net 2005 and 2010
+ (Armin Burgmeier)
+
+2.2.8:
+
+Nothing interesting. Just a small change for library.gnome.org.
+
+2.2.7:
+
+* Documentation:
+ - Added main page text with doxygen.
+ (David King, Murray Cumming)
+ - Fix the functors Doxygen group.
+ (David King)
+ - Tutorial: Removed outdated marshallers section that had no working example.
+ (Murray Cumming) Bug #417924 (Michael Ekstrand)
+
+2.2.6:
+
+* Slight documentation changes.
+ (Murray Cumming) Bug #614741 (Armin Burgmeier)
+
+2.2.5:
+
+* Accumulators: Allow return types that are different to the signal's.
+ (Krzysztof Kosiński)
+* Documentation:
+ - Disable collaboration graphs in documentation
+ - Use non-blurry font for graph labels.
+ (Daniel Elstner)
+ - sigc::hide() correction: It always only hides one signal argument.
+ (Michael Hasselmann)
+* Fix the MSVC++ build.
+ (Armin Burgmeier)
+
+2.2.4.2 (stable):
+
+* Namespace sigc is now documented, in order to make large chunks of the
+ reference reappear. (Daniel Elstner)
+* The shipped reference documentation has been regenerated using Doxygen
+ 1.6.1, so that the document type is now XHTML 1.0. (Daniel Elstner)
+* The shipped Devhelp file has been generated with a newer version of the
+ XSLT script in mm-common, so that documentation groups no longer appear
+ as namespace prefixes in the keyword list. (Daniel Elstner)
+
+2.2.4.1 (stable):
+
+* Reenable the per-class hierarchy graphs in the reference documentation.
+ (Daniel Elstner)
+* Drop the custom HTML header and footer, and use the shared doxygen.css
+ file from mm-common. (Daniel Elstner)
+
+2.2.4 (stable):
+
+* New build system based on mm-common. The mm-common module is now
+ required for building from the git repository, but not for builds
+ of release archives. (Daniel Elstner)
+* The public reference documentation is now hosted on library.gnome.org.
+ (Frédéric Péters, Daniel Elstner)
+
+2.2.3 (stable):
+
+* Windows:
+ - Added project files (and property sheets) for
+ MSVC++ 2005 and 2008.
+ (Armin Burgmeier)
+ - Removed unnecessary dependency on afxrefs.h, so it builds
+ with MSVC++ Express editions.
+ (Cedric Gustin)
+
+2.2.2 (stable):
+
+* Added an include of functors/slot.h that was mistakenly removed
+ during the 2.1 series.
+ (Deng Xiyue) Bug #521418.
+
+2.2.1 (stable):
+
+* Really fix the build with Sun CC.
+ (Elaine Xiong. Bug #302098)
+
+2.2.0 (stable):
+
+* Build fixes when using gcc 4.3 pre-releases.
+ (Ryan Hill, Vladimir Marek)
+
+2.1.1 (unstable):
+
+WARNING: This is an unstable release and should not yet be
+packaged by distributions unless libsigc++ 2.0.x does not
+build for some reason (Please report such bugs).
+
+* Removed the SigC:: namespace and other compatibility API,
+ to fix the build with some versions of some compilers,
+ such as the SUN Forte C++ CC compiler.
+ See bug #302098, for instance
+ (Murray Cumming)
+* sigc::signal<>:
+ - Added 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.
+ (Michael Elkstrand) (Bug #417926).
+ - Added emit_reverse().
+ (John Profic)
+
+2.0.17:
+
+* slot::disconnect(): Make this work.
+ sigc::connection::disconnect() already worked.
+ (James Lin, Murray Cumming)
+* visit_each compilation problem fixed.
+ (Philipp Berndt)
+
+2.0.16:
+
+* Fixed build for SUN Forte C++ 5.5
+* Fixed build for MSVC++ 7.1
+* Fixed crash when using --no-inline with g++.
+
+2.0.15:
+
+* g++ 3.2 (and Mac OS X g++ 3.3) build fix.
+ (Paul Pogonyshev)
+* Compose: Fix slot lifetime regression introduced in
+ 2.0.9. (Philip Langdale)
+* tests: Small ISO C++ correctness fix (Marek Rouchal)
+* Don't specify unused function parameter names.
+ (Andris Pavenis)
+
+2.0.14:
+
+* SUN Forte 5.7 build fix for ambiguity when using
+ inner template class. However, you still need the
+ patch in bug #302098 to finish the build.
+
+2.0.13:
+
+* signal_emit::emit(): Ensure the correct order of
+ destruction of the member variables, to avoid a leak.
+ (Andreas Ames, bug #306249)
+* Allow recursive signal emission again.
+ (Neal E. Coombes, bug #303896)
+* SUN Forte CC 5.5 build fixes:
+ - test_compatibility minor fix.
+ - visit_each() template specializations:
+ Mention the bool I_derives_trackable template type,
+ (Friedemann Kleint, bug #305647)
+ - Check for the non-standard SUN reverse_iterator,
+ and use alternative code if necessary.
+ (Murray Cumming)
+
+2.0.12:
+
+* Fixes crashes when using virtual inheritance, particularly
+ with bound by-reference parameters, caused by casting
+ from derived to base when the derived destructor has run.
+ (Régis Duchesne)
+ This might affect non-g++ compilers, so do tell us about
+ any problems.
+
+2.0.11:
+
+* Build fixes for SUN Forte, Tru64
+ (Murray Cumming), and MSVC++ (Cedric Gustin).
+
+2.0.10:
+
+* tests: Include <new> to avoid unresolved symbols on Tru64.
+ (Tim Mooney)
+* When signal handlers are connected made during an emit
+ of the same signal, prevent them from being called in the
+ same emit, to prevent infinite loops.
+ (Neal E. Coombes)
+* Performance improvement in a corner case.
+ (Neal E. Coombes).
+
+2.0.9:
+
+* sigc::bind() now works with the AIX and Tru64 compilers.
+ See the comments in sigc++/visit_each.h: visit_each_type()
+ if you have compilation problems.
+ (Murray Cumming)
+* sigc::var() is now documented. (Roger Ferrer Ibáñez)
+
+2.0.8:
+
+* Maybe avoid (incorrect) warning with g++ 3.3.5.
+ (Murray Cumming)
+* Fix namespace ambiguity when using multiple
+ major versions of libsigc++. (Liza Klerck)
+
+2.0.7:
+
+* Now builds with the following compilers, in addition to
+the existing GNU g++, SUN Forte CC 5.5, MSVC++ .Net 2003,
+and Intel compilers:
+- IBM AIX xlC v7
+- Tru64 C++ V6.5-042
+- IRIX MIPSpro 7.4.2m
+ (Older versions of all these compilers might also work.)
+ (Murray Cumming, www.thewrittenword.com)
+* MSVC++ .Net 2003 build improvements.
+ (Cedric Gustin, Timothy M. Shead)
+* Replace C-style casts with reinterpret_cast<> and
+ static_cast<>. (e97_far at e.kth.se).
+* Documentation: Added manual, based on the manual in
+ libsigc++ 1.2, but updated for the new API.
+ (Murray Cumming)
+
+
+2.0.6:
+
+* Fixed a memory leak in sigc::slot.
+* Fixed compilation for gcc-3.4.
+* Fixed compilation for Intel C++ compiler (upgraded libtool).
+* Fixed project files for MSVC .Net (Timothy M. Shead).
+* Fixed segfaults when compiled with MSVC .Net 2003 (moved
+ all calls to new and delete into non-inline library code).
+* In the compatibility module use correct bound_mem_functor
+ variants for const (volatile) methods when creating a slot.
+* Minor documentation fix.
+* Resolved bugs: #152327 #148744 #152323 #151404 #153143
+
+2.0.5:
+
+* Distribute pregenerated configuration header for MSVC .Net.
+
+2.0.4:
+
+* Fixed warnings and compiler errors in the test cases.
+* Added a new test case (Murray Cumming).
+* Fixed 'hello_world' example.
+* Don't test optional features that fail with the Sun FORTE.
+* Fixes for the Sun FORTE to compile out-of-the-box
+ (Damien Carbery, Murray Cumming, Martin Schulze).
+* Fixes for MSVC to build a DLL out-of-the-box (James Lin).
+* Improved compiler specific configuration during 'configure'.
+* Added rmp description file libsigc++-2.0.spec (Eric Bourque).
+* Minor documentation improvements (Murray Cumming).
+* Resolved bugs: #147311 #147313 #147391 #144846 #145541
+
+2.0.3:
+
+* Fix segfault on emission of unconnected signal.
+* Test emission of unconnected signals in the test case.
+* Suppress compiler warning at dynamic_cast<>-test for good.
+ (Help from Christof Petig and Timothy M. Shead.)
+
+2.0.2:
+
+* Suppress compiler warning in compatibility module at
+ dynamic_cast<>-test (fix suggested by Timothy M. Shead).
+* 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.)
+
+2.0.1:
+
+* Fixed serious bug in reference counting in sigc::signal_base::impl().
+* Fixed SigC::Object-derivation check in SigC::slot() compatibility module.
+* Fixed compilation on Apple gcc 3.3 (assisted by Spundun Bhatt).
+* Fixed configure check for gcc 3.4 (Murray Cumming).
+
+2.0.0:
+
+* Implemented sigc::connection::blocked() (Murray Cumming).
+* Added the scripts directory to the make dist target (Murray Cumming).
+* Added more documentation (Martin Schulze).
+
+1.9.16:
+
+* Fixed compiler warning in sigc::connection (Alexander Nedotsukov, Murray Cumming).
+* Fixed examples and made them part of the regular build (Murray Cumming).
+* Added header sigc++config.h for configure time checks (Murray Cumming).
+* Added configure time checks to determine the correct syntax
+ for explicit template method specializations (Murray Cumming).
+* Removed code using partial specializations of overloaded template methods
+ from test cases. SUN Forte doesn't support this feature (Martin Schulze).
+* Fixed compilation for gcc 3.4 (Murray Cumming).
+
+1.9.15:
+
+API additions:
+* Add numbered slot# templates.
+* Allow for methods of the object's base types to be passed into sigc::mem_fun().
+
+Other fixes and cleanups:
+* Make is_base_and_derived template compatible with the SUN Forte.
+* Non-template code moved from .m4 macro source to .h/.cc files (Murray Cumming).
+* Implementation moved to .cc files (Murray Cumming).
+* More fixes for the SUN Forte. Make some more ctors explicit.
+
+1.9.14:
+
+* Added sigc::slot_base::operator bool() (Murray Cumming).
+* Build docs directory by default (Murray Cumming).
+* Fixed minor doxygen issues (Murray Cumming).
+* Fixed compiler warning in signal.h (Murray Cumming).
+
+1.9.13:
+
+* Fixed passing references through sigc::slot (Reported by Jeff Franks).
+* Enabled binding of objects to method slots through sigc::bind().
+* Reworked sigc::bind() API: Made the template argument for the
+ parameter position zero-based and optional. Added overloads for
+ binding of up to 7 arguments at a time when no position is specified.
+* Reworked sigc::hide() API: Made the template argument for the
+ parameter position zero-based and optional.
+* Fixed compilation problems with MSVC .Net 2003 (Roel Vanhout).
+* Distribute MSVC .Net 2003 project files in the tarballs.
+* Improved and extended documentation.
+* Minor cleanups.
+
+1.9.12:
+
+* Added adaptor retype(). With this final API addition all adaptors
+ are in place that are available in libsigc++-1.2.
+* Added negation lambda operator. Use STL names for lambda actions.
+* Remove formerly disabled support for gcc extension typeof().
+* Added project files for MS Visual Studio .Net 2003. (Roel Vanhout)
+* Make libsigc++2 compile with .Net 2003. (Roel Vanhout, Martin Schulze)
+* Build shared version of libsigc++2 by default. (Cedric Gustin)
+* Add support for win32 platform. (Cedric Gustin)
+* Install .m4 files. (requested by Ron Steinke)
+* Cleaned up functors.
+* Restructured and completed documentation of the core library parts.
+
+1.9.11:
+
+API Additions and important bug fixes:
+* Compatibility module completed. libsigc++-1.2 filenames are preserved.
+* Fixed critical bug in auto-disconnection: don't defer detaching
+ of a slot from all referred trackables during signal emission.
+* Reduced size of slots significantly.
+* Fixed support for sigc::ref() in adaptors.
+* Fixed sigc::visit_each(): only hit targets that are passed by
+ reference; pass bound members in bound_member_functor by reference.
+* Add lambda actions sigc::{reinterpret,static,dynamic}_cast_
+ to support explicit parameter conversion.
+* Add adaptors sigc::retype_return<>() and sigc::hide_return().
+
+Minor fixes:
+* Fixed return type deduction for bind<0>.
+ libsigc++-1.9.11 should compile with gcc-3.3.
+* Fixed copy constructor and operator=() of slot template.
+* Fixed a compiler warning in signal_emit#<>::emit().
+* Improved test case.
+
+1.9.10:
+
+* Fix compiler issues with gcc-3.3.2 (patch from Jeff Franks).
+* Remove compiler check for the gcc extension typeof().
+* Simplify bind_functor templates.
+* Move definition of struct nil into functor_trait.h.
+
+1.9.9:
+
+* Add a constructor to sigc::connection that takes a slot_base&
+ to support user defined slot lists like they are used in gtkmm.
+* Fix compiler issues with gcc-3.3.2 (reported by Jeff Franks).
+
+1.9.8:
+
+* Add compatibility module that defines namespace SigC.
+ namespace SigC should be API compatible to libsigc++-1.2.
+ Currently only the core parts of the library are supported.
+ Adaptors are still to follow.
+* Fix connection::operator=(). Include connection.h in sigc++.h.
+* Get rid of namespace functor.
+* Rename dependency to destroy_notify_callback.
+* Rename trackable::clear() to trackable::notify_callbacks().
+* Move slot_base, signal_base, slot_iterator[_buf], slot_list
+ out of namespace internal. They are public API.
+* Add reference counter to signal_impl enabling signals
+ to share the underlying information.
+* Add convenience function signal#::make_slot().
+* Get rid of one-letter-parameter-names.
+* Get rid of "using namespace ..." in the test cases.
+* Add lambda operators subscript ([]) and assign (=).
+* Fix is_base_and_derived<> for const types.
+* New and updated documentation.
+* Add previous announces to file NEWS.
+
+1.9.7:
+
+* Added sigc++/sigc++.h. (Murray Cumming)
+* Added member_method example. (Murray Cumming)
+* Renamed closure to slot.
+* Fixed issues with gcc-3.3. (Adreas Rottmann)
+* Removed unnecessary void specializations.
+* Made adaptors' operator()() (overload with no arguments) return a value.
+* Made visit_each() support adaptors.
+* Overhauled return type deduction to make it work without typeof().
+* Added convinience macros SIGC_FUNCTORS_HAVE_RESULT_TYPE and
+SIGC_FUNCTOR_TRAIT(T_functor, T_result) to make return type deduction system
+support 3rd-party funtors.
+* Changed syntax of group adaptor from "[functor] % grp([lambdas])" to "group
+([functor], [lambdas])".
+* Made many fixes to lambda functionality.
+* Added var() and constant() lambda creators.
+* Added many lambda operators.
+* Added ref() which creates a reference wrapper to enable storage of
+references in bind and group adaptors.
+* Expanded test suite.
+* Added documentation. (Corrections by Murray Cumming)
+
+1.9.6:
+
+* First public release of the unstable 2.0 generation.
+ libsigc++ 2.0 uses modern C++ mechanisms to achieve a highly
+ flexible, yet typesafe callback system. It supports all features of
+ libsigc++ 1.2 and improves upon it by:
+ - No need to specify the number of arguments in signal definitions.
+ - Connection of any compatible (=implicitly convertable) functor
+ to a signal.
+ - Implicit type conversions of parameters during signal emission.
+ - Lambda adaptor for complete restructuring of functor parameter
+ lists in one line (subject to changes).
+ - Signal has a fully featured stl style list interface.
+ - A convinient accumulator API (replacing the old marshaller API).
+ - Removal of unnecessary memory management functionality.
+ - Lightweight class "trackable" for use as base class of your
+ class hierarchy replaces class "Object".
--- /dev/null
+libsigc++ -- The Typesafe Callback Framework for C++
+
+General information:
+
+ 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 gtkmm to wrap the GTK+ signal system. It does not
+ depend on GTK+ or gtkmm.
+
+ Further information is available on the libsigc++ project home page:
+ https://libsigcplusplus.github.io/libsigcplusplus/
+
+License information:
+
+ Distribution of library and components is under the LGPL as listed in the
+ file COPYING. Examples and tests are Public Domain.
+
+Contact information:
+ Maillist: mailto: libsigc-list@gnome.org
+ Homepage: https://libsigcplusplus.github.io/libsigcplusplus/
+ Online reference documentation: https://developer.gnome.org/libsigc++/unstable/
+ Download: http://ftp.gnome.org/pub/GNOME/sources/libsigc++/
+ https://download.gnome.org/sources/libsigc++/
+ Git: https://github.com/libsigcplusplus/libsigcplusplus
+ Bug reports: https://github.com/libsigcplusplus/libsigcplusplus/issues
+
+Compatibility:
+
+ Compatible compilers must support C++11, such as the decltype() specifier.
+
+ All releases are tested with the gcc (g++) compiler.
+
+# Building
+
+Whenever possible, you should use the official binary packages approved by the
+supplier of your operating system, such as your Linux distribution.
+
+## Building on Windows
+
+See MSVC_NMake/README.txt.
+
+## Building from a release tarball
+
+It's easiest to build with Meson, if the tarball was made with Meson,
+and to build with Autotools, if the tarball was made with Autotools.
+Then you don't have to use maintainer-mode.
+
+How do you know how the tarball was made? If it was made with Meson,
+it contains files in untracked/build_scripts/, untracked/docs/ and possibly
+other subdirectories of untracked/.
+
+### Building from a tarball with Meson
+
+Don't call the builddir 'build'. There is a directory called 'build' with
+files used by Autotools.
+
+If the tarball was made with Autotools, you must enable maintainer-mode:
+ $ meson --prefix=/some_directory --libdir=lib -Dmaintainer-mode=true your_builddir .
+If the tarball was made with Meson:
+ $ meson --prefix=/some_directory --libdir=lib your_builddir .
+
+Then
+ $ cd your_builddir
+ $ ninja
+ $ ninja install
+You can run the tests like so:
+ $ ninja test
+
+### Building from a tarball with Autotools
+
+If the tarball was made with Autotools:
+ $ ./configure --prefix=/some_directory
+If the tarball was made with Meson, you must enable maintainer-mode:
+ $ ./autogen.sh --prefix=/some_directory
+
+Then
+ $ make
+ $ make install
+You can build the examples and tests, and run the tests, like so:
+ $ make check
+
+## Building from git
+
+Building from git can be difficult so you should prefer building from
+a release tarball unless you need to work on the libsigc++ code itself.
+
+jhbuild can be a good help
+ https://gitlab.gnome.org/GNOME/jhbuild
+ https://wiki.gnome.org/Projects/Jhbuild
+
+### Building from git with Meson
+
+Maintainer-mode is enabled by default when you build from a git clone.
+
+Don't call the builddir 'build'. There is a directory called 'build' with
+files used by Autotools.
+
+ $ meson --prefix=/some_directory --libdir=lib your_builddir .
+ $ cd your_builddir
+ $ ninja
+ $ ninja install
+You can run the tests like so:
+ $ ninja test
+You can create a tarball like so:
+ $ ninja dist
+
+### Building from git with Autotools
+
+ $ ./autogen.sh --prefix=/some_directory
+ $ make
+ $ make install
+You can build the examples and tests, and run the tests, like so:
+ $ make check
+You can create a tarball like so:
+ $ make distcheck
+or
+ $ make dist
--- /dev/null
+#! /bin/sh -e
+test -n "$srcdir" || srcdir=`dirname "$0"`
+test -n "$srcdir" || srcdir=.
+
+mm-common-prepare --copy --force "$srcdir"
+autoreconf --force --install --verbose --warnings=all "$srcdir"
+test -n "$NOCONFIGURE" || "$srcdir/configure" --enable-maintainer-mode "$@"
--- /dev/null
+# ===========================================================================
+# http://www.gnu.org/software/autoconf-archive/ax_boost_base.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+# AX_BOOST_BASE([MINIMUM-VERSION], [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
+#
+# DESCRIPTION
+#
+# Test for the Boost C++ libraries of a particular version (or newer)
+#
+# If no path to the installed boost library is given the macro searchs
+# under /usr, /usr/local, /opt and /opt/local and evaluates the
+# $BOOST_ROOT environment variable. Further documentation is available at
+# <http://randspringer.de/boost/index.html>.
+#
+# This macro calls:
+#
+# AC_SUBST(BOOST_CPPFLAGS) / AC_SUBST(BOOST_LDFLAGS)
+#
+# And sets:
+#
+# HAVE_BOOST
+#
+# LICENSE
+#
+# Copyright (c) 2008 Thomas Porschberg <thomas@randspringer.de>
+# Copyright (c) 2009 Peter Adolphs
+#
+# Copying and distribution of this file, with or without modification, are
+# permitted in any medium without royalty provided the copyright notice
+# and this notice are preserved. This file is offered as-is, without any
+# warranty.
+
+#serial 26
+
+AC_DEFUN([AX_BOOST_BASE],
+[
+AC_ARG_WITH([boost],
+ [AS_HELP_STRING([--with-boost@<:@=ARG@:>@],
+ [use Boost library from a standard location (ARG=yes),
+ from the specified location (ARG=<path>),
+ or disable it (ARG=no)
+ @<:@ARG=yes@:>@ ])],
+ [
+ if test "$withval" = "no"; then
+ want_boost="no"
+ elif test "$withval" = "yes"; then
+ want_boost="yes"
+ ac_boost_path=""
+ else
+ want_boost="yes"
+ ac_boost_path="$withval"
+ fi
+ ],
+ [want_boost="yes"])
+
+
+AC_ARG_WITH([boost-libdir],
+ AS_HELP_STRING([--with-boost-libdir=LIB_DIR],
+ [Force given directory for boost libraries. Note that this will override library path detection, so use this parameter only if default library detection fails and you know exactly where your boost libraries are located.]),
+ [
+ if test -d "$withval"
+ then
+ ac_boost_lib_path="$withval"
+ else
+ AC_MSG_ERROR(--with-boost-libdir expected directory name)
+ fi
+ ],
+ [ac_boost_lib_path=""]
+)
+
+if test "x$want_boost" = "xyes"; then
+ boost_lib_version_req=ifelse([$1], ,1.20.0,$1)
+ boost_lib_version_req_shorten=`expr $boost_lib_version_req : '\([[0-9]]*\.[[0-9]]*\)'`
+ boost_lib_version_req_major=`expr $boost_lib_version_req : '\([[0-9]]*\)'`
+ boost_lib_version_req_minor=`expr $boost_lib_version_req : '[[0-9]]*\.\([[0-9]]*\)'`
+ boost_lib_version_req_sub_minor=`expr $boost_lib_version_req : '[[0-9]]*\.[[0-9]]*\.\([[0-9]]*\)'`
+ if test "x$boost_lib_version_req_sub_minor" = "x" ; then
+ boost_lib_version_req_sub_minor="0"
+ fi
+ WANT_BOOST_VERSION=`expr $boost_lib_version_req_major \* 100000 \+ $boost_lib_version_req_minor \* 100 \+ $boost_lib_version_req_sub_minor`
+ AC_MSG_CHECKING(for boostlib >= $boost_lib_version_req)
+ succeeded=no
+
+ dnl On 64-bit systems check for system libraries in both lib64 and lib.
+ dnl The former is specified by FHS, but e.g. Debian does not adhere to
+ dnl this (as it rises problems for generic multi-arch support).
+ dnl The last entry in the list is chosen by default when no libraries
+ dnl are found, e.g. when only header-only libraries are installed!
+ libsubdirs="lib"
+ ax_arch=`uname -m`
+ case $ax_arch in
+ x86_64)
+ libsubdirs="lib64 libx32 lib lib64"
+ ;;
+ ppc64|s390x|sparc64|aarch64|ppc64le)
+ libsubdirs="lib64 lib lib64 ppc64le"
+ ;;
+ esac
+
+ dnl allow for real multi-arch paths e.g. /usr/lib/x86_64-linux-gnu. Give
+ dnl them priority over the other paths since, if libs are found there, they
+ dnl are almost assuredly the ones desired.
+ AC_REQUIRE([AC_CANONICAL_HOST])
+ libsubdirs="lib/${host_cpu}-${host_os} $libsubdirs"
+
+ case ${host_cpu} in
+ i?86)
+ libsubdirs="lib/i386-${host_os} $libsubdirs"
+ ;;
+ esac
+
+ dnl first we check the system location for boost libraries
+ dnl this location ist chosen if boost libraries are installed with the --layout=system option
+ dnl or if you install boost with RPM
+ if test "$ac_boost_path" != ""; then
+ BOOST_CPPFLAGS="-I$ac_boost_path/include"
+ for ac_boost_path_tmp in $libsubdirs; do
+ if test -d "$ac_boost_path"/"$ac_boost_path_tmp" ; then
+ BOOST_LDFLAGS="-L$ac_boost_path/$ac_boost_path_tmp"
+ break
+ fi
+ done
+ elif test "$cross_compiling" != yes; then
+ for ac_boost_path_tmp in /usr /usr/local /opt /opt/local ; do
+ if test -d "$ac_boost_path_tmp/include/boost" && test -r "$ac_boost_path_tmp/include/boost"; then
+ for libsubdir in $libsubdirs ; do
+ if ls "$ac_boost_path_tmp/$libsubdir/libboost_"* >/dev/null 2>&1 ; then break; fi
+ done
+ BOOST_LDFLAGS="-L$ac_boost_path_tmp/$libsubdir"
+ BOOST_CPPFLAGS="-I$ac_boost_path_tmp/include"
+ break;
+ fi
+ done
+ fi
+
+ dnl overwrite ld flags if we have required special directory with
+ dnl --with-boost-libdir parameter
+ if test "$ac_boost_lib_path" != ""; then
+ BOOST_LDFLAGS="-L$ac_boost_lib_path"
+ fi
+
+ CPPFLAGS_SAVED="$CPPFLAGS"
+ CPPFLAGS="$CPPFLAGS $BOOST_CPPFLAGS"
+ export CPPFLAGS
+
+ LDFLAGS_SAVED="$LDFLAGS"
+ LDFLAGS="$LDFLAGS $BOOST_LDFLAGS"
+ export LDFLAGS
+
+ AC_REQUIRE([AC_PROG_CXX])
+ AC_LANG_PUSH(C++)
+ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+ @%:@include <boost/version.hpp>
+ ]], [[
+ #if BOOST_VERSION >= $WANT_BOOST_VERSION
+ // Everything is okay
+ #else
+ # error Boost version is too old
+ #endif
+ ]])],[
+ AC_MSG_RESULT(yes)
+ succeeded=yes
+ found_system=yes
+ ],[
+ ])
+ AC_LANG_POP([C++])
+
+
+
+ dnl if we found no boost with system layout we search for boost libraries
+ dnl built and installed without the --layout=system option or for a staged(not installed) version
+ if test "x$succeeded" != "xyes"; then
+ CPPFLAGS="$CPPFLAGS_SAVED"
+ LDFLAGS="$LDFLAGS_SAVED"
+ BOOST_CPPFLAGS=
+ BOOST_LDFLAGS=
+ _version=0
+ if test "$ac_boost_path" != ""; then
+ if test -d "$ac_boost_path" && test -r "$ac_boost_path"; then
+ for i in `ls -d $ac_boost_path/include/boost-* 2>/dev/null`; do
+ _version_tmp=`echo $i | sed "s#$ac_boost_path##" | sed 's/\/include\/boost-//' | sed 's/_/./'`
+ V_CHECK=`expr $_version_tmp \> $_version`
+ if test "$V_CHECK" = "1" ; then
+ _version=$_version_tmp
+ fi
+ VERSION_UNDERSCORE=`echo $_version | sed 's/\./_/'`
+ BOOST_CPPFLAGS="-I$ac_boost_path/include/boost-$VERSION_UNDERSCORE"
+ done
+ dnl if nothing found search for layout used in Windows distributions
+ if test -z "$BOOST_CPPFLAGS"; then
+ if test -d "$ac_boost_path/boost" && test -r "$ac_boost_path/boost"; then
+ BOOST_CPPFLAGS="-I$ac_boost_path"
+ fi
+ fi
+ fi
+ else
+ if test "$cross_compiling" != yes; then
+ for ac_boost_path in /usr /usr/local /opt /opt/local ; do
+ if test -d "$ac_boost_path" && test -r "$ac_boost_path"; then
+ for i in `ls -d $ac_boost_path/include/boost-* 2>/dev/null`; do
+ _version_tmp=`echo $i | sed "s#$ac_boost_path##" | sed 's/\/include\/boost-//' | sed 's/_/./'`
+ V_CHECK=`expr $_version_tmp \> $_version`
+ if test "$V_CHECK" = "1" ; then
+ _version=$_version_tmp
+ best_path=$ac_boost_path
+ fi
+ done
+ fi
+ done
+
+ VERSION_UNDERSCORE=`echo $_version | sed 's/\./_/'`
+ BOOST_CPPFLAGS="-I$best_path/include/boost-$VERSION_UNDERSCORE"
+ if test "$ac_boost_lib_path" = ""; then
+ for libsubdir in $libsubdirs ; do
+ if ls "$best_path/$libsubdir/libboost_"* >/dev/null 2>&1 ; then break; fi
+ done
+ BOOST_LDFLAGS="-L$best_path/$libsubdir"
+ fi
+ fi
+
+ if test "x$BOOST_ROOT" != "x"; then
+ for libsubdir in $libsubdirs ; do
+ if ls "$BOOST_ROOT/stage/$libsubdir/libboost_"* >/dev/null 2>&1 ; then break; fi
+ done
+ if test -d "$BOOST_ROOT" && test -r "$BOOST_ROOT" && test -d "$BOOST_ROOT/stage/$libsubdir" && test -r "$BOOST_ROOT/stage/$libsubdir"; then
+ version_dir=`expr //$BOOST_ROOT : '.*/\(.*\)'`
+ stage_version=`echo $version_dir | sed 's/boost_//' | sed 's/_/./g'`
+ stage_version_shorten=`expr $stage_version : '\([[0-9]]*\.[[0-9]]*\)'`
+ V_CHECK=`expr $stage_version_shorten \>\= $_version`
+ if test "$V_CHECK" = "1" -a "$ac_boost_lib_path" = "" ; then
+ AC_MSG_NOTICE(We will use a staged boost library from $BOOST_ROOT)
+ BOOST_CPPFLAGS="-I$BOOST_ROOT"
+ BOOST_LDFLAGS="-L$BOOST_ROOT/stage/$libsubdir"
+ fi
+ fi
+ fi
+ fi
+
+ CPPFLAGS="$CPPFLAGS $BOOST_CPPFLAGS"
+ export CPPFLAGS
+ LDFLAGS="$LDFLAGS $BOOST_LDFLAGS"
+ export LDFLAGS
+
+ AC_LANG_PUSH(C++)
+ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+ @%:@include <boost/version.hpp>
+ ]], [[
+ #if BOOST_VERSION >= $WANT_BOOST_VERSION
+ // Everything is okay
+ #else
+ # error Boost version is too old
+ #endif
+ ]])],[
+ AC_MSG_RESULT(yes)
+ succeeded=yes
+ found_system=yes
+ ],[
+ ])
+ AC_LANG_POP([C++])
+ fi
+
+ if test "$succeeded" != "yes" ; then
+ if test "$_version" = "0" ; then
+ AC_MSG_NOTICE([[We could not detect the boost libraries (version $boost_lib_version_req_shorten or higher). If you have a staged boost library (still not installed) please specify \$BOOST_ROOT in your environment and do not give a PATH to --with-boost option. If you are sure you have boost installed, then check your version number looking in <boost/version.hpp>. See http://randspringer.de/boost for more documentation.]])
+ else
+ AC_MSG_NOTICE([Your boost libraries seems to old (version $_version).])
+ fi
+ # execute ACTION-IF-NOT-FOUND (if present):
+ ifelse([$3], , :, [$3])
+ else
+ AC_SUBST(BOOST_CPPFLAGS)
+ AC_SUBST(BOOST_LDFLAGS)
+ AC_DEFINE(HAVE_BOOST,,[define if the Boost library is available])
+ # execute ACTION-IF-FOUND (if present):
+ ifelse([$2], , :, [$2])
+ fi
+
+ CPPFLAGS="$CPPFLAGS_SAVED"
+ LDFLAGS="$LDFLAGS_SAVED"
+fi
+
+])
--- /dev/null
+# ===========================================================================
+# http://www.gnu.org/software/autoconf-archive/ax_boost_system.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+# AX_BOOST_SYSTEM
+#
+# DESCRIPTION
+#
+# Test for System library from the Boost C++ libraries. The macro requires
+# a preceding call to AX_BOOST_BASE. Further documentation is available at
+# <http://randspringer.de/boost/index.html>.
+#
+# This macro calls:
+#
+# AC_SUBST(BOOST_SYSTEM_LIB)
+#
+# And sets:
+#
+# HAVE_BOOST_SYSTEM
+#
+# LICENSE
+#
+# Copyright (c) 2008 Thomas Porschberg <thomas@randspringer.de>
+# Copyright (c) 2008 Michael Tindal
+# Copyright (c) 2008 Daniel Casimiro <dan.casimiro@gmail.com>
+#
+# Copying and distribution of this file, with or without modification, are
+# permitted in any medium without royalty provided the copyright notice
+# and this notice are preserved. This file is offered as-is, without any
+# warranty.
+
+#serial 17
+
+AC_DEFUN([AX_BOOST_SYSTEM],
+[
+ AC_ARG_WITH([boost-system],
+ AS_HELP_STRING([--with-boost-system@<:@=special-lib@:>@],
+ [use the System library from boost - it is possible to specify a certain library for the linker
+ e.g. --with-boost-system=boost_system-gcc-mt ]),
+ [
+ if test "$withval" = "no"; then
+ want_boost="no"
+ elif test "$withval" = "yes"; then
+ want_boost="yes"
+ ax_boost_user_system_lib=""
+ else
+ want_boost="yes"
+ ax_boost_user_system_lib="$withval"
+ fi
+ ],
+ [want_boost="yes"]
+ )
+
+ if test "x$want_boost" = "xyes"; then
+ AC_REQUIRE([AC_PROG_CC])
+ AC_REQUIRE([AC_CANONICAL_BUILD])
+ CPPFLAGS_SAVED="$CPPFLAGS"
+ CPPFLAGS="$CPPFLAGS $BOOST_CPPFLAGS"
+ export CPPFLAGS
+
+ LDFLAGS_SAVED="$LDFLAGS"
+ LDFLAGS="$LDFLAGS $BOOST_LDFLAGS"
+ export LDFLAGS
+
+ AC_CACHE_CHECK(whether the Boost::System library is available,
+ ax_cv_boost_system,
+ [AC_LANG_PUSH([C++])
+ CXXFLAGS_SAVE=$CXXFLAGS
+
+ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@include <boost/system/error_code.hpp>]],
+ [[boost::system::system_category]])],
+ ax_cv_boost_system=yes, ax_cv_boost_system=no)
+ CXXFLAGS=$CXXFLAGS_SAVE
+ AC_LANG_POP([C++])
+ ])
+ if test "x$ax_cv_boost_system" = "xyes"; then
+ AC_SUBST(BOOST_CPPFLAGS)
+
+ AC_DEFINE(HAVE_BOOST_SYSTEM,,[define if the Boost::System library is available])
+ BOOSTLIBDIR=`echo $BOOST_LDFLAGS | sed -e 's/@<:@^\/@:>@*//'`
+
+ LDFLAGS_SAVE=$LDFLAGS
+ if test "x$ax_boost_user_system_lib" = "x"; then
+ for libextension in `ls -r $BOOSTLIBDIR/libboost_system* 2>/dev/null | sed 's,.*/lib,,' | sed 's,\..*,,'` ; do
+ ax_lib=${libextension}
+ AC_CHECK_LIB($ax_lib, exit,
+ [BOOST_SYSTEM_LIB="-l$ax_lib"; AC_SUBST(BOOST_SYSTEM_LIB) link_system="yes"; break],
+ [link_system="no"])
+ done
+ if test "x$link_system" != "xyes"; then
+ for libextension in `ls -r $BOOSTLIBDIR/boost_system* 2>/dev/null | sed 's,.*/,,' | sed -e 's,\..*,,'` ; do
+ ax_lib=${libextension}
+ AC_CHECK_LIB($ax_lib, exit,
+ [BOOST_SYSTEM_LIB="-l$ax_lib"; AC_SUBST(BOOST_SYSTEM_LIB) link_system="yes"; break],
+ [link_system="no"])
+ done
+ fi
+
+ else
+ for ax_lib in $ax_boost_user_system_lib boost_system-$ax_boost_user_system_lib; do
+ AC_CHECK_LIB($ax_lib, exit,
+ [BOOST_SYSTEM_LIB="-l$ax_lib"; AC_SUBST(BOOST_SYSTEM_LIB) link_system="yes"; break],
+ [link_system="no"])
+ done
+
+ fi
+ if test "x$ax_lib" = "x"; then
+ AC_MSG_ERROR(Could not find a version of the library!)
+ fi
+ if test "x$link_system" = "xno"; then
+ AC_MSG_ERROR(Could not link against $ax_lib !)
+ fi
+ fi
+
+ CPPFLAGS="$CPPFLAGS_SAVED"
+ LDFLAGS="$LDFLAGS_SAVED"
+ fi
+])
+
--- /dev/null
+# ===========================================================================
+# http://www.gnu.org/software/autoconf-archive/ax_boost_timer.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+# AX_BOOST_TIMER
+#
+# DESCRIPTION
+#
+# Test for System library from the Boost C++ libraries. The macro requires
+# a preceding call to AX_BOOST_BASE. Further documentation is available at
+# <http://randspringer.de/boost/index.html>.
+#
+# This macro calls:
+#
+# AC_SUBST(BOOST_TIMER_LIB)
+#
+# And sets:
+#
+# HAVE_BOOST_TIMER
+#
+# LICENSE
+#
+# Copyright (c) 2012 Xiyue Deng <manphiz@gmail.com>
+# Copyright (c) 2012 Murray Cumming <murrayc@openismus.com>
+#
+# Copying and distribution of this file, with or without modification, are
+# permitted in any medium without royalty provided the copyright notice
+# and this notice are preserved. This file is offered as-is, without any
+# warranty.
+
+#serial 2 (based on serial 1 of ax_boost_locale.m4 with some simple find/replace by Murray Cumming)
+
+AC_DEFUN([AX_BOOST_TIMER],
+[
+ AC_ARG_WITH([boost-timer],
+ AS_HELP_STRING([--with-boost-timer@<:@=special-lib@:>@],
+ [use the Timer library from boost - it is possible to specify a certain library for the linker
+ e.g. --with-boost-timer=boost_timer-gcc-mt ]),
+ [
+ if test "$withval" = "no"; then
+ want_boost="no"
+ elif test "$withval" = "yes"; then
+ want_boost="yes"
+ ax_boost_user_timer_lib=""
+ else
+ want_boost="yes"
+ ax_boost_user_timer_lib="$withval"
+ fi
+ ],
+ [want_boost="yes"]
+ )
+
+ if test "x$want_boost" = "xyes"; then
+ AC_REQUIRE([AC_PROG_CC])
+ AC_REQUIRE([AC_CANONICAL_BUILD])
+ CPPFLAGS_SAVED="$CPPFLAGS"
+ CPPFLAGS="$CPPFLAGS $BOOST_CPPFLAGS"
+ export CPPFLAGS
+
+ LDFLAGS_SAVED="$LDFLAGS"
+ LDFLAGS="$LDFLAGS $BOOST_LDFLAGS"
+ export LDFLAGS
+
+ AC_CACHE_CHECK(whether the Boost::Timer library is available,
+ ax_cv_boost_timer,
+ [AC_LANG_PUSH([C++])
+ CXXFLAGS_SAVE=$CXXFLAGS
+
+ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@include <boost/timer/timer.hpp>]],
+ [[boost::timer::cpu_timer().stop();]])],
+ ax_cv_boost_timer=yes, ax_cv_boost_timer=no)
+ CXXFLAGS=$CXXFLAGS_SAVE
+ AC_LANG_POP([C++])
+ ])
+ if test "x$ax_cv_boost_timer" = "xyes"; then
+ AC_SUBST(BOOST_CPPFLAGS)
+
+ AC_DEFINE(HAVE_BOOST_TIMER,,[define if the Boost::Timer library is available])
+ BOOSTLIBDIR=`echo $BOOST_LDFLAGS | sed -e 's/@<:@^\/@:>@*//'`
+
+ LDFLAGS_SAVE=$LDFLAGS
+ if test "x$ax_boost_user_timer_lib" = "x"; then
+ for libextension in `ls $BOOSTLIBDIR/libboost_timer*.so* $BOOSTLIBDIR/libboost_timer*.dylib* $BOOSTLIBDIR/libboost_timer*.a* 2>/dev/null | sed 's,.*/,,' | sed -e 's;^lib\(boost_timer.*\)\.so.*$;\1;' -e 's;^lib\(boost_timer.*\)\.dylib.*$;\1;' -e 's;^lib\(boost_timer.*\)\.a.*$;\1;'` ; do
+ ax_lib=${libextension}
+ AC_CHECK_LIB($ax_lib, exit,
+ [BOOST_TIMER_LIB="-l$ax_lib"; AC_SUBST(BOOST_TIMER_LIB) link_timer="yes"; break],
+ [link_timer="no"])
+ done
+ if test "x$link_timer" != "xyes"; then
+ for libextension in `ls $BOOSTLIBDIR/boost_timer*.dll* $BOOSTLIBDIR/boost_timer*.a* 2>/dev/null | sed 's,.*/,,' | sed -e 's;^\(boost_timer.*\)\.dll.*$;\1;' -e 's;^\(boost_timer.*\)\.a.*$;\1;'` ; do
+ ax_lib=${libextension}
+ AC_CHECK_LIB($ax_lib, exit,
+ [BOOST_TIMER_LIB="-l$ax_lib"; AC_SUBST(BOOST_TIMER_LIB) link_timer="yes"; break],
+ [link_timer="no"])
+ done
+ fi
+
+ else
+ for ax_lib in $ax_boost_user_timer_lib boost_timer-$ax_boost_user_timer_lib; do
+ AC_CHECK_LIB($ax_lib, exit,
+ [BOOST_TIMER_LIB="-l$ax_lib"; AC_SUBST(BOOST_TIMER_LIB) link_timer="yes"; break],
+ [link_timer="no"])
+ done
+
+ fi
+ if test "x$ax_lib" = "x"; then
+ AC_MSG_ERROR(Could not find a version of the library!)
+ fi
+ if test "x$link_timer" = "xno"; then
+ AC_MSG_ERROR(Could not link against $ax_lib !)
+ fi
+ fi
+
+ CPPFLAGS="$CPPFLAGS_SAVED"
+ LDFLAGS="$LDFLAGS_SAVED"
+ fi
+])
--- /dev/null
+dnl
+dnl SIGC_CXX_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD()
+dnl
+dnl
+AC_DEFUN([SIGC_CXX_GCC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD],[
+AC_MSG_CHECKING([if C++ compiler supports the use of a particular specialization when calling operator() template methods.])
+AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
+[[
+ #include <iostream>
+
+ class Thing
+ {
+ public:
+ Thing()
+ {}
+
+ template <class T>
+ void operator()(T a, T b)
+ {
+ T c = a + b;
+ std::cout << c << std::endl;
+ }
+ };
+
+ template<class T2>
+ class OtherThing
+ {
+ public:
+ void do_something()
+ {
+ Thing thing_;
+ thing_.template operator()<T2>(1, 2);
+ //This fails with or without the template keyword, on SUN Forte C++ 5.3, 5.4, and 5.5:
+ }
+ };
+]],
+[[
+ OtherThing<int> thing;
+ thing.do_something();
+]])],
+[
+ sigcm_cxx_gcc_template_specialization_operator_overload=yes
+ AC_DEFINE([SIGC_GCC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD],[1],[does the C++ compiler support the use of a particular specialization when calling operator() template methods.])
+],[
+ sigcm_cxx_gcc_template_specialization_operator_overload=no
+])
+AC_MSG_RESULT([$sigcm_cxx_gcc_template_specialization_operator_overload])
+])
+
+AC_DEFUN([SIGC_CXX_MSVC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD],[
+AC_MSG_CHECKING([if C++ compiler supports the use of a particular specialization when calling operator() template methods omitting the template keyword.])
+AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
+[[
+ #include <iostream>
+
+ class Thing
+ {
+ public:
+ Thing()
+ {}
+
+ template <class T>
+ void operator()(T a, T b)
+ {
+ T c = a + b;
+ std::cout << c << std::endl;
+ }
+ };
+
+ template<class T2>
+ class OtherThing
+ {
+ public:
+ void do_something()
+ {
+ Thing thing_;
+ thing_.operator()<T2>(1, 2);
+ //This fails with or without the template keyword, on SUN Forte C++ 5.3, 5.4, and 5.5:
+ }
+ };
+]],
+[[
+ OtherThing<int> thing;
+ thing.do_something();
+]])],
+[
+ sigcm_cxx_msvc_template_specialization_operator_overload=yes
+ AC_DEFINE([SIGC_MSVC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD],[1],[does the C++ compiler support the use of a particular specialization when calling operator() template methods omitting the template keyword.])
+],[
+ sigcm_cxx_msvc_template_specialization_operator_overload=no
+])
+AC_MSG_RESULT([$sigcm_cxx_msvc_template_specialization_operator_overload])
+])
+
+dnl
+dnl SIGC_CXX_PRAGMA_PUSH_POP_MACRO
+dnl
+dnl TODO: When we can break ABI, delete this. It's used when nil is
+dnl temporarily undefined. See comment in functor_trait.h.
+dnl
+AC_DEFUN([SIGC_CXX_PRAGMA_PUSH_POP_MACRO],[
+AC_MSG_CHECKING([if C++ preprocessor supports pragma push_macro() and pop_macro().])
+AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
+[[
+ #define BEGIN {
+ #define END }
+ #pragma push_macro("BEGIN")
+ #pragma push_macro("END")
+ #undef BEGIN
+ #undef END
+
+ // BEGIN and END are not prepreprocessor macros
+ struct Test1
+ {
+ int BEGIN;
+ double END;
+ };
+
+ #pragma pop_macro("BEGIN")
+ #pragma pop_macro("END")
+
+ // BEGIN and END are prepreprocessor macros
+ struct Test2
+ BEGIN
+ int i;
+ double d;
+ END;
+
+ void func1(Test1& x);
+ void func2(Test2& x);
+]],
+[[
+ Test1 test1;
+ Test2 test2;
+ func1(test1);
+ func2(test2);
+]])],
+[
+ sigcm_cxx_pragma_push_pop_macro=yes
+ AC_DEFINE([SIGC_PRAGMA_PUSH_POP_MACRO],[1],[does the C++ preprocessor support pragma push_macro() and pop_macro().])
+],[
+ sigcm_cxx_pragma_push_pop_macro=no
+])
+AC_MSG_RESULT([$sigcm_cxx_pragma_push_pop_macro])
+])
--- /dev/null
+## SIGC_CXX_HAS_SUN_REVERSE_ITERATOR()
+##
+## Check for Sun libCstd style std::reverse_iterator, which demands more than just one template parameter.
+## and #define SIGC_HAVE_SUN_REVERSE_ITERATOR if found.
+##
+AC_DEFUN([SIGC_CXX_HAS_SUN_REVERSE_ITERATOR],
+[
+ AC_CACHE_CHECK(
+ [for non-standard Sun libCstd reverse_iterator],
+ [sigc_cv_cxx_has_sun_reverse_iterator],
+ [
+ AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
+ [[
+ #include <iterator>
+ ]],[[
+ typedef std::reverse_iterator<char*, std::random_access_iterator_tag, char, char&, char*, int> ReverseIter;
+ ]])],
+ [sigc_cv_cxx_has_sun_reverse_iterator='yes'],
+ [sigc_cv_cxx_has_sun_reverse_iterator='no']
+ )
+ ])
+
+ AS_IF([test "x${sigc_cv_cxx_has_sun_reverse_iterator}" = 'xyes'],
+ [AC_DEFINE([SIGC_HAVE_SUN_REVERSE_ITERATOR], [1], [Define if the non-standard Sun reverse_iterator must be used.])])
+])
--- /dev/null
+## Copyright (c) 2009 Openismus GmbH <http://www.openismus.com/>
+##
+## This file is part of libsigc++.
+##
+## libsigc++ 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.
+##
+## libsigc++ 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 <http://www.gnu.org/licenses/>.
+
+AC_INIT([libsigc++], [2.10.8],
+ [https://github.com/libsigcplusplus/libsigcplusplus/issues/],
+ [libsigc++], [https://libsigcplusplus.github.io/libsigcplusplus/])
+AC_PREREQ([2.59])
+
+AC_CONFIG_SRCDIR([sigc++/sigc++.h])
+AC_CONFIG_AUX_DIR([build])
+AC_CONFIG_MACRO_DIR([build])
+AC_CONFIG_HEADERS([config.h sigc++config.h])
+
+AM_INIT_AUTOMAKE([1.9 -Wno-portability check-news no-dist-gzip dist-xz tar-ustar no-define nostdinc])
+# Support silent build rules.
+# Disable by either passing --disable-silent-rules to configure or passing V=1 to make.
+m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
+AM_MAINTAINER_MODE
+AC_ARG_VAR([ACLOCAL_FLAGS], [aclocal flags, e.g. -I <macro dir>])
+
+MM_PREREQ([0.9.10])
+MM_INIT_MODULE([sigc++-2.0])
+MM_CONFIG_DOCTOOL_DIR([docs])
+
+AC_PROG_CXX
+MM_AX_CXX_COMPILE_STDCXX([11], [noext], [mandatory])
+
+AC_DISABLE_STATIC
+LT_INIT([win32-dll])
+
+AC_ARG_VAR([M4], [M4 macro processor command])
+AC_CHECK_PROGS([M4], [gm4 m4])
+
+AS_IF([test "x$M4" = x],
+ [AC_MSG_FAILURE([[The GNU M4 macro processor is required for building libsigc++.]])])
+
+MM_ARG_ENABLE_DOCUMENTATION
+MM_ARG_WITH_TAGFILE_DOC([libstdc++.tag], [mm-common-libstdc++])
+
+AC_LANG([C++])
+SIGC_CXX_GCC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+SIGC_CXX_MSVC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+SIGC_CXX_PRAGMA_PUSH_POP_MACRO
+SIGC_CXX_HAS_SUN_REVERSE_ITERATOR
+
+AS_IF([test "x$config_error" = xyes],
+ [AC_MSG_FAILURE([[One or more of the required C++ compiler features is missing.]])])
+
+# Evaluate the --enable-warnings=level option.
+MM_ARG_ENABLE_WARNINGS([SIGC_WXXFLAGS],
+ [-Wall],
+ [-pedantic -Wall -Wextra -Wsuggest-override -Wshadow -Wzero-as-null-pointer-constant -Wformat-security])
+
+# Offer the ability to omit some API from the library.
+MM_ARG_DISABLE_DEPRECATED_API([SIGCXX])
+
+AC_ARG_ENABLE(benchmark,
+ AS_HELP_STRING([--enable-benchmark=yes|no])
+)
+
+AM_CONDITIONAL([SIGC_BUILD_BENCHMARK], [test "x$enable_benchmark" = xyes])
+
+AS_IF([test "x$enable_benchmark" = xyes],[
+ #Use boost::timer for our benchmark, if it's available.
+ # See http://www.gnu.org/software/autoconf-archive/ax_boost_base.html
+ # Boost System is needed by Boost Timer
+ AX_BOOST_BASE
+ AX_BOOST_SYSTEM
+ AX_BOOST_TIMER
+])
+
+AC_CONFIG_FILES([Makefile
+ ${SIGCXX_MODULE_NAME}.pc:sigc++.pc.in
+ ${SIGCXX_MODULE_NAME}-uninstalled.pc:sigc++-uninstalled.pc.in
+ sigc++/Makefile
+ examples/Makefile
+ tests/Makefile
+ docs/Makefile
+ docs/reference/Doxyfile
+ MSVC_NMake/sigc.rc])
+
+# Copy the generated configuration headers into the MSVC project directories.
+AC_CONFIG_COMMANDS([MSVC_NMake/sigc++config.h],
+ [cp -f sigc++config.h MSVC_NMake/sigc++config.h])
+AC_OUTPUT
--- /dev/null
+## Copyright (c) 2009 Openismus GmbH <http://www.openismus.com/>
+##
+## This file is part of libsigc++.
+##
+## libsigc++ 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.
+##
+## libsigc++ 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 <http://www.gnu.org/licenses/>.
+
+include $(top_srcdir)/sigc++/filelist.am
+
+book_name = libsigc++-$(SIGCXX_API_VERSION)
+
+# For each header file, test whether it exists in the build directory.
+# If it does, return its relative path. Otherwise, assume the file is
+# present in the source directory and return the relative path to that
+# location.
+libsigc_h = $(sigc_public_h) $(sigc_built_h)
+vp_select = $(or $(wildcard $(top_builddir)/sigc++/$(file)),$(top_srcdir)/sigc++/$(file))
+vp_search = $(foreach file,$(libsigc_h),$(vp_select))
+doc_input = $(if $(srcdir:.=),$(vp_search),$(addprefix $(top_builddir)/sigc++/,$(libsigc_h))) \
+ $(top_srcdir)/sigc++/sigc++.h
+
+include $(top_srcdir)/build/doc-reference.am
+
+doc_imagesdir = $(libdocdir)/images
+dist_libdoc_DATA = index.html
+dist_doc_images_DATA = images/libsigc_logo.gif images/top.gif
+
+dist_noinst_DATA += doc-install.pl doc-postprocess.pl doxygen.css tagfile-to-devhelp2.xsl
+
+include $(srcdir)/doc-manual.am
--- /dev/null
+## Copyright (c) 2009 Openismus GmbH <http://www.openismus.com/>
+##
+## This file is part of libsigc++.
+##
+## libsigc++ 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.
+##
+## libsigc++ 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 <http://www.gnu.org/licenses/>.
+
+DOCBOOK_STYLESHEET ?= http://docbook.sourceforge.net/release/xsl/current/html/chunk.xsl
+
+html_tutorialdir = $(libdocdir)/tutorial/html
+dist_html_tutorial_DATA = $(sort manual/html/index.html $(call vpath_listall,manual/html/*.html))
+
+dist_noinst_DATA += manual/libsigc_manual.xml
+
+DISTCLEANFILES += $(addprefix manual/libsigc_manual.,dvi pdf ps)
+MAINTAINERCLEANFILES += manual/html/*
+
+# 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
+xslt_params = $(strip \
+ --param toc.section.depth 1 \
+ --stringparam chunker.output.indent 'yes' \
+ --stringparam chunker.output.encoding 'UTF-8' \
+ --stringparam toc.list.type 'ul' \
+ --stringparam use.id.as.filename '1' \
+ )
+
+manual_srcfile = $(srcdir)/manual/libsigc_manual.xml
+
+# Make sure that the documentation will always have been generated before
+# executing the commands of a rule that depends on files in reference/html/.
+reference/html/%: | manual/html/index.html
+
+manual/html/index.html: $(manual_srcfile)
+ -$(AM_V_at)rm -f manual/html/*
+ $(AM_V_at)$(MKDIR_P) manual/html
+ $(AM_V_GEN)xsltproc $(xslt_params) -o manual/html/ --catalogs '$(DOCBOOK_STYLESHEET)' $(manual_srcfile)
+
+manual/libsigc_manual.dvi: $(manual_srcfile)
+ $(AM_V_GEN)db2dvi -o manual $(manual_srcfile)
+
+manual/libsigc_manual.pdf: $(manual_srcfile)
+ $(AM_V_GEN)db2pdf -o manual $(manual_srcfile)
+
+manual/libsigc_manual.ps: $(manual_srcfile)
+ $(AM_V_GEN)db2ps -o manual $(manual_srcfile)
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+<head>
+ <title>libsigc Documentation</title>
+ <meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1">
+ <link href="http://library.gnome.org/devel/libsigc++/stable/doxygen.css" rel="stylesheet"
+ type="text/css">
+ <style type="text/css">
+ body {
+ font-family: Verdana, Arial, Helvetica, sans-serif;
+ font-size: 15px;
+ }
+ </style>
+</head>
+<body bgcolor="#f0f0f0">
+<div align="center"> <a class="qindex" href="index.html">Main Page</a>
+ <a class="qindex" href="http://library.gnome.org/devel/libsigc++/stable/namespaces.html">Namespaces</a>
+
+<hr>
+<h1>libsigc++ 2 documentation</h1>
+<table cellspacing="1" cellpadding="2" width="100%" border="0">
+ <tbody>
+ <tr>
+ <th bgcolor="#bd2c4a"
+ style="border: 1px solid black; color: white;">API Reference</th>
+ </tr>
+ <tr>
+ <td valign="top">
+ <table border="0" bgcolor="white" width="100%" cellpadding="2"
+ cellspacing="1" style="border: 1px solid black;">
+ <tbody>
+ <tr>
+ <th bgcolor="#f0f0f0" width="33%">Groups</th>
+ <th bgcolor="#f0f0f0" width="33%">Namespaces</th>
+ <th bgcolor="#f0f0f0" width="33%">Full</th>
+ </tr>
+ <tr>
+ <td valign="top" width="33%">
+ <ul>
+ <li><a href="http://library.gnome.org/devel/libsigc++/stable/group__signal.html">Signals</a></li>
+ <li><a href="http://library.gnome.org/devel/libsigc++/stable/group__slot.html">Slots</a></li>
+ <li><a href="http://library.gnome.org/devel/libsigc++/stable/group__sigcfunctors.html">Functors</a></li>
+ <li><a href="http://library.gnome.org/devel/libsigc++/stable/group__adaptors.html">Adaptors</a></li>
+ </ul>
+ </td>
+ <td valign="top" width="33%">
+ <ul>
+ <li><a href="http://library.gnome.org/devel/libsigc++/stable/namespacesigc.html">sigc</a></li>
+ </ul>
+ </td>
+ <td valign="top" width="33%">
+ <ul>
+ <li><a href="http://library.gnome.org/devel/libsigc++/stable/hierarchy.html">Inheritance
+Hierarchy</a></li>
+ <li><a href="http://library.gnome.org/devel/libsigc++/stable/inherits.html">Class Chart
+(image)</a></li>
+ <li><a href="http://library.gnome.org/devel/libsigc++/stable/classes.html">All Classes</a></li>
+ <li><a href="http://library.gnome.org/devel/libsigc++/stable/functions.html">All methods
+(long)</a></li>
+ </ul>
+ </td>
+ </tr>
+ </tbody>
+ </table>
+ </td>
+ </tr>
+ </tbody>
+</table>
+<br>
+</div>
+</body>
+</html>
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<book xmlns="http://docbook.org/ns/docbook"
+ version="5.0" xml:id="index" xml:lang="en">
+
+<title>xmllint test</title>
+
+<chapter xml:id="chapter-introduction">
+<title>Introduction</title>
+ <para>
+ This is a short DocBook V5.0 document. It can be used for testing if the installed
+ version of xmllint or a similar program can validate a DocBook V5.0 document.
+ </para>
+</chapter>
+
+</book>
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<book xmlns="http://docbook.org/ns/docbook"
+ xmlns:xlink="http://www.w3.org/1999/xlink"
+ version="5.0" xml:id="index" xml:lang="en">
+
+<info>
+ <title>libsigc++</title>
+ <author><personname>
+ <firstname>Ainsley</firstname>
+ <surname>Pereira</surname>
+ </personname></author>
+ <date>September 2002</date>
+ <pubdate>September 2002. Updated January 2004 by Murray Cumming</pubdate>
+ <abstract>
+ <para>libsigc++ is a C++ template library implementing typesafe callbacks. This is an intro to libsigc++.</para>
+ </abstract>
+</info>
+
+<chapter xml:id="chapter-introduction">
+<info><title>Introduction</title></info>
+
+<section xml:id="sect-motivation">
+<info><title>Motivation</title></info>
+
+ <para>There are many situations in which it is desirable to decouple code that
+ detects an event, and the code that deals with it. This is especially common in
+ GUI programming, where a toolkit might provide user interface elements such as
+ clickable buttons but, being a generic toolkit, doesn't know how an individual
+ application using that toolkit should handle the user clicking on it.</para>
+
+ <para>In C the callbacks are generally handled by the application calling a
+ 'register' function and passing a pointer to a function and a <literal remap="tt">void*</literal>
+ argument, eg.</para>
+
+<programlisting>
+void clicked(void* data);
+
+button* okbutton = create_button("ok");
+static char somedata[] = "This is some data I want the clicked() function to have";
+
+register_click_handler(okbutton, clicked, somedata);
+</programlisting>
+
+ <para>When clicked, the toolkit will call <literal remap="tt">clicked()</literal> with the data pointer passed
+ to the <literal remap="tt">register_click_handler()</literal> function.</para>
+
+ <para>This works in C, but is not typesafe. There is no compile-time way of
+ ensuring that <literal remap="tt">clicked()</literal> isn't expecting a struct of some sort instead of a
+ <literal remap="tt">char*</literal>.</para>
+
+ <para>As C++ programmers, we want type safety. We also want to be able to use
+ things other than free-standing functions as callbacks.</para>
+
+ <para>libsigc++ provides the concept of a slot, which holds a reference to one of
+ the things that can be used as a callback:
+ <itemizedlist>
+ <listitem><para>A free-standing function as in the example</para></listitem>
+ <listitem><para>A functor object that defines operator() (a lambda expression
+ is such an object)</para></listitem>
+ <listitem><para>A pointer-to-a-member-function and an instance of an object on which to invoke it (the
+ object should inherit from <literal remap="tt">sigc::trackable</literal>)</para></listitem>
+ </itemizedlist></para>
+
+ <para>All of which can take different numbers and types of arguments.</para>
+
+ <para>To make it easier to construct these, libsigc++ provides the sigc::ptr_fun() and sigc::mem_fun() functions, for creating slots from static functions and member functions, respectively. They return
+ a generic <literal remap="tt">signal::slot</literal> type that can be invoked with <literal remap="tt">emit()</literal> or <literal remap="tt">operator()</literal>.</para>
+
+ <para>For the other side of the fence, libsigc++ provides <literal remap="tt">signal</literal>s, to which the
+ client can attach <literal remap="tt">slot</literal>s. When the <literal remap="tt">signal</literal> is emitted, all the connected
+ <literal remap="tt">slot</literal>s are called.</para>
+</section>
+</chapter>
+
+<chapter xml:id="chapter-connecting">
+<info><title>Connecting your code to signals</title></info>
+
+<section xml:id="sect-simple-ex">
+<info><title>A simple example</title></info>
+
+ <para>So to get some experience, lets look at a simple example...</para>
+
+ <para>Lets say you and I are writing an application which informs the user when
+ aliens land in the car park. To keep the design nice and clean, and allow for
+ maximum portability to different interfaces, we decide to use libsigc++ to
+ split the project in two parts.</para>
+
+ <para>I will write the <literal remap="tt">AlienDetector</literal> class, and you will write the code to inform
+ the user. (Well, OK, I'll write both, but we're pretending, remember?)</para>
+
+ <para>Here's my class:</para>
+
+<programlisting>
+class AlienDetector
+{
+public:
+ AlienDetector();
+
+ void run();
+
+ sigc::signal<void()> signal_detected;
+};
+</programlisting>
+
+ <para>(I'll explain the type of signal_detected later.)</para>
+
+ <para>Here's your code that uses it:</para>
+
+<programlisting>
+void warn_people()
+{
+ std::cout << "There are aliens in the carpark!" << std::endl;
+}
+
+int main()
+{
+ AlienDetector mydetector;
+ mydetector.signal_detected.connect( sigc::ptr_fun(warn_people) );
+
+ mydetector.run();
+
+ return 0;
+}
+</programlisting>
+
+ <para>You can use a lambda expression instead of sigc::ptr_fun().</para>
+<programlisting>
+ mydetector.signal_detected.connect( [](){ warn_people(); } );
+</programlisting>
+
+ <para>Pretty simple really - you call the <literal remap="tt">connect()</literal> method on the signal to
+ connect your function. <literal remap="tt">connect()</literal> takes a <literal remap="tt">slot</literal> parameter (remember slots
+ are capable of holding any type of callback), so you convert your
+ <literal remap="tt">warn_people()</literal> function to a slot using the <literal remap="tt">slot()</literal> function.</para>
+
+ <para>To compile this example, use:</para>
+ <programlisting>g++ example1.cc -o example1 `pkg-config --cflags --libs sigc++-2.0`</programlisting>
+ <para>Note that those `` characters are backticks, not single quotes. Run it with</para>
+ <programlisting>./example1</programlisting>
+ <para>(Try not to panic when the aliens land!)</para>
+
+</section>
+
+<section xml:id="sect-using-mem-func">
+<info><title>Using a member function</title></info>
+
+ <para>Suppose you found a more sophisticated alien alerter class on the web,
+ such as this:</para>
+
+<programlisting>
+class AlienAlerter : public sigc::trackable
+{
+public:
+ AlienAlerter(char const* servername);
+ void alert();
+private:
+ // ...
+};
+</programlisting>
+
+ <para>(Handily it derives from <literal remap="tt">sigc::trackable</literal> already. This isn't quite so
+ unlikely as you might think; all appropriate bits of the popular gtkmm library do so,
+ for example.)</para>
+
+ <para>You could rewrite your code as follows:</para>
+
+<programlisting>
+int main()
+{
+ AlienDetector mydetector;
+ AlienAlerter myalerter("localhost"); // added
+ mydetector.signal_detected.connect( sigc::mem_fun(myalerter, &AlienAlerter::alert) ); // changed
+
+ mydetector.run();
+
+ return 0;
+}
+</programlisting>
+
+ <para>Note that only 2 lines are different - one to create an instance of the
+ class, and the line to connect the method to the signal.</para>
+
+ <para>This code is in example2.cc, which can be compiled in the same way as
+ example1.cc</para>
+
+ <para>It's possible to use a lambda expression instead of sigc::mem_fun(),
+ but it's not recommended, if the class derives from <literal remap="tt">sigc::trackable</literal>.
+ With a lambda expression you would lose the automatic disconnection that the
+ combination of <literal remap="tt">sigc::trackable</literal> and sigc::mem_fun()
+ offers.</para>
+</section>
+
+<section xml:id="sect-signals-with-pars">
+<info><title>Signals with parameters</title></info>
+
+ <para>Functions taking no parameters and returning void are quite useful,
+ especially when they're members of classes that can store unlimited amounts of
+ safely typed data, but they're not sufficient for everything.</para>
+
+ <para>What if aliens don't land in the carpark, but somewhere else? Let's modify
+ the example so that the callback function takes a <literal remap="tt">std::string</literal> with the location
+ in which aliens were detected.</para>
+
+ <para>I change my class to:</para>
+
+<programlisting>
+class AlienDetector
+{
+public:
+ AlienDetector();
+
+ void run();
+
+ sigc::signal<void(std::string)> signal_detected; // changed
+};
+</programlisting>
+
+ <para>The only line I had to change was the signal line (in <literal remap="tt">run()</literal> I need to change
+ my code to supply the argument when I emit the signal too, but that's not shown
+ here).</para>
+
+ <para>The name of the type is '<literal remap="tt">sigc::signal</literal>'.
+ The template parameters are the return type, then the argument types in parentheses.
+ (libsigc++2 also accepts a different syntax, with a comma between the return type
+ and the parameter types. That syntax is deprecated, though.)</para>
+
+ <para>The types in the function signature are in the same order as the template
+ parameters, eg:</para>
+
+<programlisting>
+sigc::signal<void(std::string)>
+ void function(std::string foo);
+</programlisting>
+
+ <para>So now you can update your alerter (for simplicity, lets go back to the
+ free-standing function version):</para>
+
+<programlisting>
+void warn_people(std::string where)
+{
+ std::cout << "There are aliens in " << where << "!" << std::endl;
+}
+
+int main()
+{
+ AlienDetector mydetector;
+ mydetector.signal_detected.connect( sigc::ptr_fun(warn_people) );
+
+ mydetector.run();
+
+ return 0;
+}
+</programlisting>
+
+ <para>Easy.</para>
+</section>
+
+<section xml:id="sect-disconnecting">
+<info><title>Disconnecting</title></info>
+
+ <para>If you decide you no longer want your code to be called whenever a signal is
+ emitted, you must remember the return value of <literal remap="tt">connect()</literal>, which we've been
+ ignoring until now.</para>
+
+ <para><literal remap="tt">connect()</literal> returns a <literal remap="tt">sigc::connection</literal> object, which has a <literal remap="tt">disconnect()</literal> member method. This does just what you think it does.</para>
+
+</section>
+</chapter>
+
+<chapter xml:id="chapter-writing">
+<info><title>Writing your own signals</title></info>
+
+<section xml:id="sect-quick-recap">
+<info><title>Quick recap</title></info>
+
+ <para>If all you want to do is use gtkmm, and connect your functionality to its
+ signals, you can probably stop reading here.</para>
+
+ <para>You might benefit from reading on anyway though, as this section is going to
+ be quite simple, and the 'Rebinding' technique from the next section is
+ occasionally useful.</para>
+
+ <para>We've already covered the way the types of signals are made up, but lets
+ recap:</para>
+
+ <para>A signal is an instance of a template, named <literal remap="tt">sigc::signal</literal>.
+ The template arguments are the types,
+ in the order they appear in the function signature that can be connected to that
+ signal; that is the return type, then the argument types in parentheses.</para>
+
+ <para>To provide a signal for people to connect to, you must make available an
+ instance of that <literal remap="tt">sigc::signal</literal>. In <literal remap="tt">AlienDetector</literal> this was done
+ with a public data member. That's not considered good practice usually, so you
+ might want to consider making a member function that returns the signal by
+ reference. (This is what gtkmm does.)</para>
+
+ <para>Once you've done this, all you have to do is emit the signal when you're
+ ready. Look at the code for <literal remap="tt">AlienDetector::run()</literal>:</para>
+
+<programlisting>
+void AlienDetector::run()
+{
+ sleep(3); // wait for aliens
+ signal_detected.emit(); // panic!
+}
+</programlisting>
+
+ <para>As a shortcut, <literal remap="tt">sigc::signal</literal> defines <literal remap="tt">operator()</literal> as a synonym for
+ <literal remap="tt">emit()</literal>, so you could just write <literal remap="tt">signal_detected();</literal> as in the second
+ example version:</para>
+
+<programlisting>
+void AlienDetector::run()
+{
+ sleep(3); // wait for aliens
+ signal_detected("the carpark"); // this is the std::string version, looks like
+ // they landed in the carpark after all.
+}
+</programlisting>
+</section>
+
+<section xml:id="sect-return-values">
+<info><title>What about return values?</title></info>
+
+ <para>If you only ever have one slot connected to a signal, or if you only care
+ about the return value of the last registered one, it's quite straightforward:</para>
+
+<programlisting>
+sigc::signal<int()> somesignal;
+int a_return_value;
+
+a_return_value = somesignal.emit();
+</programlisting>
+</section>
+</chapter>
+
+<chapter xml:id="chapter-advanced">
+<info><title>Advanced topics</title></info>
+
+<section xml:id="sect-rebinding">
+<info><title>Rebinding</title></info>
+
+ <para>Suppose you already have a function that you want to be called when a
+ signal is emitted, but it takes the wrong argument types. For example, lets try
+ to attach the <literal remap="tt">warn_people(std::string)</literal> function to the detected signal
+ from the first example, which didn't supply a location string.</para>
+
+ <para>Just trying to connect it with:</para>
+
+<programlisting>
+myaliendetector.signal_detected.connect(sigc::ptr_fun(warn_people));
+</programlisting>
+
+ <para>results in a compile-time error, because the types don't match. This is good!
+ This is typesafety at work. In the C way of doing things, this would have just
+ died at runtime after trying to print a random bit of memory as the location -
+ ick!</para>
+
+ <para>We have to make up a location string, and bind it to the function, so that
+ when signal_detected is emitted with no arguments, something adds it in before
+ <literal remap="tt">warn_people</literal> is actually called.</para>
+ <para>We could write it ourselves - it's not hard:</para>
+
+<programlisting>
+void warn_people_wrapper() // note this is the signature that 'signal_detected' expects
+{
+ warn_people("the carpark");
+}
+</programlisting>
+
+ <para>but after our first million or so we might start looking for a better way. As
+ it happens, libsigc++ has one.</para>
+
+<programlisting>
+sigc::bind(slot, arg);
+</programlisting>
+
+ <para>binds arg as the argument to slot, and returns a new slot of the same return
+ type, but with one fewer arguments.</para>
+
+ <para>Now we can write:</para>
+<programlisting>
+myaliendetector.signal_detected.connect(sigc::bind( sigc::ptr_fun(warn_people), "the carpark" ) );
+</programlisting>
+
+ <para>If the input slot has multiple args, the rightmost one is bound.</para>
+
+ <para>The return type can also be bound with <literal remap="tt">sigc::bind_return(slot, returnvalue);</literal> though
+ this is not so commonly useful.</para>
+
+ <para>So if we can attach the new <literal remap="tt">warn_people()</literal> to the old detector, can we attach
+ the old <literal remap="tt">warn_people</literal> (the one that didn't take an argument) to the new detector?</para>
+
+ <para>Of course, we just need to hide the extra argument. This can be done with
+ <literal remap="tt">sigc::hide</literal>, eg.</para>
+
+<programlisting>
+myaliendetector.signal_detected.connect( sigc::hide<std::string>( sigc::ptr_fun(warn_people) ) );
+</programlisting>
+
+ <para>The template arguments are the types to hide (from the right only - you can't
+ hide the first argument of 3, for example, only the last).</para>
+
+ <para><literal remap="tt">sigc::hide_return</literal> effectively makes the return type void.</para>
+</section>
+
+<section xml:id="sect-retyping">
+<info><title>Retyping</title></info>
+
+ <para>A similar topic is retyping. Perhaps you have a signal that takes an <literal remap="tt">int</literal>, but
+ you want to connect a function that takes a <literal remap="tt">double</literal>.</para>
+
+ <para>This can be achieved with the <literal remap="tt">sigc::retype()</literal> template.
+ It takes a <literal remap="tt">sigc::slot</literal>, and returns a <literal remap="tt">sigc::slot</literal>. eg.</para>
+
+<programlisting>
+void dostuff(double foo)
+{
+}
+
+sigc::signal<void(int)> asignal;
+
+asignal.connect( sigc::retype( sigc::ptr_fun(&dostuff) ) );
+</programlisting>
+
+ <para>If you only want to change the return type, you can use <literal remap="tt">sigc::retype_return()</literal>.
+ <literal remap="tt">retype_return()</literal> needs one template argument, the new return type.</para>
+</section>
+</chapter>
+
+<chapter xml:id="chapter-reference">
+<info><title>Reference</title></info>
+
+ <para>See the reference documentation <link xlink:href="http://library.gnome.org/devel/libsigc++/2.10/">online</link></para>
+</chapter>
+</book>
--- /dev/null
+# docs/manual
+
+# input: install_datadir, sigcxx_pcname, tutorial_custom_cmd, python3,
+# build_documentation, install_docdir, can_add_dist_script, xsltproc
+# output: can_parse_and_validate, build_pdf_by_default, can_build_pdf,
+# install_tutorialdir
+
+xmllint = find_program('xmllint', required: false)
+can_parse_and_validate = xmllint.found()
+
+validate = get_option('validation') ? 'true' : 'false'
+
+dblatex = find_program('dblatex', required: false)
+can_build_pdf = dblatex.found() or (xsltproc.found() and \
+ find_program('fop', required: false).found())
+build_pdf_by_default = get_option('build-pdf')
+
+# Installation directories are relative to {prefix}.
+install_tutorialdir = install_docdir / 'tutorial'
+
+if not build_documentation
+ # Documentation shall not be built or installed.
+ # Return to the calling meson.build file.
+ subdir_done()
+endif
+
+# Check if xmllint can be used.
+if xmllint.found()
+ can_parse_and_validate = run_command(
+ python3, tutorial_custom_cmd, 'xmllint',
+ validate,
+ meson.current_source_dir() / 'can_use_xmllint.xml',
+ meson.current_build_dir() / 'can_use_xmllint.stamp',
+ check: false,
+ ).returncode() == 0
+ if not can_parse_and_validate
+ # The DocBook V5.0 package is called docbook5-xml in Ubuntu,
+ # docbook5-schemas in Fedora. It may have other names in other distros.
+ warning('Can\'t validate XML file.\n' +
+ 'xmllint does not support Relax NG schemas and DocBook V5.0.\n' +
+ 'DocBook V5.0 support may require docbook5-xml, docbook5-schemas or a similar package.'
+ )
+ endif
+endif
+
+install_data('..' / 'index.html', install_dir: install_docdir)
+install_data('..' / 'images' / 'libsigc_logo.gif',
+ '..' / 'images' / 'top.gif',
+ install_dir: install_docdir / 'images')
+
+doc_dist_dir = 'untracked' / 'docs' / 'manual' # Relative to MESON_DIST_ROOT
+
+sigc_manual_xml = 'libsigc_manual.xml'
+sigc_manual_pdf = 'libsigc_manual.pdf'
+
+# Create an html version of the DocBook.
+custom_target('manual_html',
+ input: sigc_manual_xml,
+ output: 'html',
+ command: [
+ python3, tutorial_custom_cmd, 'html',
+ '@INPUT@',
+ '@OUTPUT@',
+ ],
+ build_by_default: true,
+ install: true,
+ install_dir: install_tutorialdir
+)
+
+if can_parse_and_validate
+ # Parse and possibly validate the DocBook.
+ custom_target('manual_xmllint',
+ input: sigc_manual_xml,
+ output: 'manual_xmllint.stamp',
+ command: [
+ python3, tutorial_custom_cmd, 'xmllint',
+ validate,
+ '@INPUT@',
+ '@OUTPUT@'
+ ],
+ build_by_default: true,
+ )
+endif
+
+if can_build_pdf
+ # Create a PDF file of the DocBook.
+ # Prefer dblatex, if both dblatex and fop are available.
+ custom_target('manual_pdf',
+ input: sigc_manual_xml,
+ output: sigc_manual_pdf,
+ command: [
+ python3, tutorial_custom_cmd,
+ dblatex.found() ? 'dblatex' : 'fop',
+ '@INPUT@',
+ '@OUTPUT@'
+ ],
+ build_by_default: build_pdf_by_default,
+ )
+endif
+
+if can_add_dist_script
+ # Distribute built files.
+ meson.add_dist_script(
+ python3, tutorial_custom_cmd, 'dist_doc',
+ doc_dist_dir,
+ meson.current_build_dir(),
+ meson.current_source_dir() / sigc_manual_xml,
+ meson.current_build_dir() / sigc_manual_pdf,
+ )
+endif
--- /dev/null
+# Doxyfile 1.8.11
+# @configure_input@
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+DOXYFILE_ENCODING = UTF-8
+PROJECT_NAME = @PACKAGE_NAME@
+PROJECT_NUMBER = @PACKAGE_VERSION@
+PROJECT_BRIEF =
+PROJECT_LOGO =
+OUTPUT_DIRECTORY = reference
+CREATE_SUBDIRS = NO
+ALLOW_UNICODE_NAMES = NO
+OUTPUT_LANGUAGE = English
+BRIEF_MEMBER_DESC = YES
+REPEAT_BRIEF = YES
+ABBREVIATE_BRIEF =
+ALWAYS_DETAILED_SEC = NO
+INLINE_INHERITED_MEMB = NO
+FULL_PATH_NAMES = YES
+STRIP_FROM_PATH = "@abs_top_builddir@/" \
+ "@abs_top_srcdir@/"
+STRIP_FROM_INC_PATH = "@abs_top_builddir@/" \
+ "@abs_top_srcdir@/"
+SHORT_NAMES = NO
+JAVADOC_AUTOBRIEF = YES
+QT_AUTOBRIEF = NO
+MULTILINE_CPP_IS_BRIEF = NO
+INHERIT_DOCS = YES
+SEPARATE_MEMBER_PAGES = NO
+TAB_SIZE = 8
+ALIASES = "newin{2}=\xrefitem since_\1_\2 \"Since @PACKAGE_NAME@ \1.\2\" \"New API in @PACKAGE_NAME@ \1.\2\"" \
+ "newin{3}=\xrefitem since_\1_\2_\3 \"Since @PACKAGE_NAME@ \1.\2.\3\" \"New API in @PACKAGE_NAME@ \1.\2.\3\""
+OPTIMIZE_OUTPUT_FOR_C = NO
+OPTIMIZE_OUTPUT_JAVA = NO
+OPTIMIZE_FOR_FORTRAN = NO
+OPTIMIZE_OUTPUT_VHDL = NO
+EXTENSION_MAPPING =
+MARKDOWN_SUPPORT = YES
+AUTOLINK_SUPPORT = YES
+BUILTIN_STL_SUPPORT = NO
+CPP_CLI_SUPPORT = NO
+SIP_SUPPORT = NO
+IDL_PROPERTY_SUPPORT = YES
+DISTRIBUTE_GROUP_DOC = NO
+GROUP_NESTED_COMPOUNDS = NO
+SUBGROUPING = YES
+INLINE_GROUPED_CLASSES = NO
+INLINE_SIMPLE_STRUCTS = NO
+TYPEDEF_HIDES_STRUCT = NO
+LOOKUP_CACHE_SIZE = 0
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+EXTRACT_ALL = YES
+EXTRACT_PRIVATE = NO
+EXTRACT_PACKAGE = NO
+EXTRACT_STATIC = NO
+EXTRACT_LOCAL_CLASSES = NO
+EXTRACT_LOCAL_METHODS = NO
+EXTRACT_ANON_NSPACES = NO
+HIDE_UNDOC_MEMBERS = NO
+HIDE_UNDOC_CLASSES = NO
+HIDE_FRIEND_COMPOUNDS = YES
+HIDE_IN_BODY_DOCS = YES
+INTERNAL_DOCS = NO
+CASE_SENSE_NAMES = YES
+HIDE_SCOPE_NAMES = NO
+HIDE_COMPOUND_REFERENCE= NO
+SHOW_INCLUDE_FILES = YES
+SHOW_GROUPED_MEMB_INC = NO
+FORCE_LOCAL_INCLUDES = NO
+INLINE_INFO = YES
+SORT_MEMBER_DOCS = YES
+SORT_BRIEF_DOCS = YES
+SORT_MEMBERS_CTORS_1ST = YES
+SORT_GROUP_NAMES = YES
+SORT_BY_SCOPE_NAME = YES
+STRICT_PROTO_MATCHING = NO
+GENERATE_TODOLIST = NO
+GENERATE_TESTLIST = NO
+GENERATE_BUGLIST = NO
+GENERATE_DEPRECATEDLIST= YES
+ENABLED_SECTIONS =
+MAX_INITIALIZER_LINES = 2
+SHOW_USED_FILES = NO
+SHOW_FILES = NO
+SHOW_NAMESPACES = YES
+FILE_VERSION_FILTER =
+LAYOUT_FILE =
+CITE_BIB_FILES =
+#---------------------------------------------------------------------------
+# Configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+QUIET = YES
+WARNINGS = YES
+WARN_IF_UNDOCUMENTED = YES
+WARN_IF_DOC_ERROR = YES
+WARN_NO_PARAMDOC = NO
+WARN_AS_ERROR = NO
+WARN_FORMAT = "$file:$line: $text"
+WARN_LOGFILE = reference/doxygen.log
+#---------------------------------------------------------------------------
+# Configuration options related to the input files
+#---------------------------------------------------------------------------
+INPUT =
+INPUT_ENCODING = UTF-8
+FILE_PATTERNS =
+RECURSIVE = NO
+EXCLUDE =
+EXCLUDE_SYMLINKS = NO
+EXCLUDE_PATTERNS =
+EXCLUDE_SYMBOLS = _* \
+ basic_filebuf \
+ binary_function \
+ internal \
+ pair \
+ unary_function \
+ hash_load_check_resize_trigger_size_base \
+ lu_counter_policy_base
+EXAMPLE_PATH = "@abs_top_srcdir@/examples"
+EXAMPLE_PATTERNS = *.cc \
+ *.h
+EXAMPLE_RECURSIVE = NO
+IMAGE_PATH =
+INPUT_FILTER =
+FILTER_PATTERNS =
+FILTER_SOURCE_FILES = NO
+FILTER_SOURCE_PATTERNS =
+USE_MDFILE_AS_MAINPAGE =
+#---------------------------------------------------------------------------
+# Configuration options related to source browsing
+#---------------------------------------------------------------------------
+SOURCE_BROWSER = NO
+INLINE_SOURCES = NO
+STRIP_CODE_COMMENTS = NO
+REFERENCED_BY_RELATION = NO
+REFERENCES_RELATION = NO
+REFERENCES_LINK_SOURCE = YES
+SOURCE_TOOLTIPS = YES
+USE_HTAGS = NO
+VERBATIM_HEADERS = NO
+CLANG_ASSISTED_PARSING = NO
+CLANG_OPTIONS =
+#---------------------------------------------------------------------------
+# Configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+ALPHABETICAL_INDEX = YES
+IGNORE_PREFIX =
+#---------------------------------------------------------------------------
+# Configuration options related to the HTML output
+#---------------------------------------------------------------------------
+GENERATE_HTML = YES
+HTML_OUTPUT = html
+HTML_FILE_EXTENSION = .html
+HTML_HEADER =
+HTML_FOOTER =
+HTML_STYLESHEET =
+HTML_EXTRA_STYLESHEET = "$(MMDOCTOOLDIR)/doxygen-extra.css"
+HTML_EXTRA_FILES =
+HTML_COLORSTYLE_HUE = 220
+HTML_COLORSTYLE_SAT = 100
+HTML_COLORSTYLE_GAMMA = 80
+HTML_TIMESTAMP = YES
+HTML_DYNAMIC_SECTIONS = NO
+HTML_INDEX_NUM_ENTRIES = 100
+GENERATE_DOCSET = NO
+DOCSET_FEEDNAME = "Doxygen generated docs"
+DOCSET_BUNDLE_ID = org.doxygen.Project
+DOCSET_PUBLISHER_ID = org.doxygen.Publisher
+DOCSET_PUBLISHER_NAME = Publisher
+GENERATE_HTMLHELP = NO
+CHM_FILE =
+HHC_LOCATION =
+GENERATE_CHI = NO
+CHM_INDEX_ENCODING =
+BINARY_TOC = NO
+TOC_EXPAND = NO
+GENERATE_QHP = NO
+QCH_FILE =
+QHP_NAMESPACE =
+QHP_VIRTUAL_FOLDER = doc
+QHP_CUST_FILTER_NAME =
+QHP_CUST_FILTER_ATTRS =
+QHP_SECT_FILTER_ATTRS =
+QHG_LOCATION =
+GENERATE_ECLIPSEHELP = NO
+ECLIPSE_DOC_ID = org.doxygen.Project
+DISABLE_INDEX = NO
+GENERATE_TREEVIEW = NO
+ENUM_VALUES_PER_LINE = 1
+TREEVIEW_WIDTH = 250
+EXT_LINKS_IN_WINDOW = NO
+FORMULA_FONTSIZE = 10
+FORMULA_TRANSPARENT = YES
+USE_MATHJAX = NO
+MATHJAX_FORMAT = HTML-CSS
+MATHJAX_RELPATH = http://cdn.mathjax.org/mathjax/latest
+MATHJAX_EXTENSIONS =
+MATHJAX_CODEFILE =
+SEARCHENGINE = NO
+SERVER_BASED_SEARCH = NO
+EXTERNAL_SEARCH = NO
+SEARCHENGINE_URL =
+SEARCHDATA_FILE = searchdata.xml
+EXTERNAL_SEARCH_ID =
+EXTRA_SEARCH_MAPPINGS =
+#---------------------------------------------------------------------------
+# Configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+GENERATE_LATEX = NO
+LATEX_OUTPUT = latex
+LATEX_CMD_NAME = latex
+MAKEINDEX_CMD_NAME = makeindex
+COMPACT_LATEX = NO
+PAPER_TYPE = a4
+EXTRA_PACKAGES =
+LATEX_HEADER =
+LATEX_FOOTER =
+LATEX_EXTRA_STYLESHEET =
+LATEX_EXTRA_FILES =
+PDF_HYPERLINKS = YES
+USE_PDFLATEX = YES
+LATEX_BATCHMODE = NO
+LATEX_HIDE_INDICES = NO
+LATEX_SOURCE_CODE = NO
+LATEX_BIB_STYLE = plain
+LATEX_TIMESTAMP = NO
+#---------------------------------------------------------------------------
+# Configuration options related to the RTF output
+#---------------------------------------------------------------------------
+GENERATE_RTF = NO
+RTF_OUTPUT = rtf
+COMPACT_RTF = NO
+RTF_HYPERLINKS = NO
+RTF_STYLESHEET_FILE =
+RTF_EXTENSIONS_FILE =
+RTF_SOURCE_CODE = NO
+#---------------------------------------------------------------------------
+# Configuration options related to the man page output
+#---------------------------------------------------------------------------
+GENERATE_MAN = NO
+MAN_OUTPUT = man
+MAN_EXTENSION = .3
+MAN_SUBDIR =
+MAN_LINKS = NO
+#---------------------------------------------------------------------------
+# Configuration options related to the XML output
+#---------------------------------------------------------------------------
+GENERATE_XML = NO
+XML_OUTPUT = xml
+XML_PROGRAMLISTING = NO
+#---------------------------------------------------------------------------
+# Configuration options related to the DOCBOOK output
+#---------------------------------------------------------------------------
+GENERATE_DOCBOOK = NO
+DOCBOOK_OUTPUT = docbook
+DOCBOOK_PROGRAMLISTING = NO
+#---------------------------------------------------------------------------
+# Configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+GENERATE_AUTOGEN_DEF = NO
+#---------------------------------------------------------------------------
+# Configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+GENERATE_PERLMOD = NO
+PERLMOD_LATEX = NO
+PERLMOD_PRETTY = YES
+PERLMOD_MAKEVAR_PREFIX =
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+ENABLE_PREPROCESSING = YES
+MACRO_EXPANSION = YES
+EXPAND_ONLY_PREDEF = YES
+SEARCH_INCLUDES = YES
+INCLUDE_PATH = "@abs_top_builddir@" \
+ "@abs_top_srcdir@"
+INCLUDE_FILE_PATTERNS = *.h
+PREDEFINED = __cplusplus \
+ DOXYGEN_SHOULD_SKIP_THIS \
+ "SIGC_API=" \
+ SIGC_CONFIGURE \
+ SIGC_GCC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD \
+ SIGC_MSVC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD \
+ SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+EXPAND_AS_DEFINED = SIGC_WORKAROUND_OPERATOR_PARENTHESES \
+ SIGCXX_MAJOR_VERSION \
+ SIGCXX_MINOR_VERSION \
+ SIGCXX_MICRO_VERSION
+SKIP_FUNCTION_MACROS = YES
+#---------------------------------------------------------------------------
+# Configuration options related to external references
+#---------------------------------------------------------------------------
+TAGFILES = @DOXYGEN_TAGFILES@
+GENERATE_TAGFILE = "reference/libsigc++-@SIGCXX_API_VERSION@.tag"
+ALLEXTERNALS = NO
+EXTERNAL_GROUPS = NO
+EXTERNAL_PAGES = YES
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+CLASS_DIAGRAMS = YES
+DIA_PATH =
+HIDE_UNDOC_RELATIONS = NO
+HAVE_DOT = YES
+DOT_NUM_THREADS = 0
+DOT_FONTNAME = Sans
+DOT_FONTSIZE = 10
+DOT_FONTPATH =
+CLASS_GRAPH = YES
+COLLABORATION_GRAPH = NO
+GROUP_GRAPHS = NO
+UML_LOOK = NO
+UML_LIMIT_NUM_FIELDS = 10
+TEMPLATE_RELATIONS = NO
+INCLUDE_GRAPH = NO
+INCLUDED_BY_GRAPH = NO
+CALL_GRAPH = NO
+CALLER_GRAPH = NO
+GRAPHICAL_HIERARCHY = YES
+DIRECTORY_GRAPH = NO
+DOT_IMAGE_FORMAT = png
+INTERACTIVE_SVG = NO
+DOT_PATH =
+DOTFILE_DIRS =
+MSCFILE_DIRS =
+DIAFILE_DIRS =
+PLANTUML_JAR_PATH =
+PLANTUML_INCLUDE_PATH =
+DOT_GRAPH_MAX_NODES = 50
+MAX_DOT_GRAPH_DEPTH = 0
+DOT_TRANSPARENT = NO
+DOT_MULTI_TARGETS = YES
+GENERATE_LEGEND = YES
+DOT_CLEANUP = YES
--- /dev/null
+# docs/reference
+
+# Input: built_files_root, project_source_root, sigcxx_pcname,
+# sigcxx_api_version, build_documentation, source_h_files,
+# built_h_files, install_datadir, python3, doc_reference,
+# built_h_file_targets, can_add_dist_script
+# Output: install_docdir, install_devhelpdir, if build_documentation: tag_file
+
+tag_file_modules = [
+ 'mm-common-libstdc++',
+]
+doxygen_tagfiles = ''
+doxygen_tag_targets = []
+docinstall_flags = []
+foreach module : tag_file_modules
+ depmod = dependency(module, required: false)
+ if depmod.found()
+ doxytagfile = depmod.get_variable(pkgconfig: 'doxytagfile', internal: 'doxytagfile', default_value: '')
+ if doxytagfile != ''
+ if depmod.type_name() == 'internal'
+ # Subprojects must build their tag files before doxygen is called.
+ if module.startswith('mm-common')
+ doxygen_tag_targets += subproject('mm-common').get_variable('global_tag_file_target')
+ else
+ doxygen_tag_targets += subproject(module).get_variable('global_tag_file_target')
+ endif
+ endif
+ htmlrefpub = depmod.get_variable(pkgconfig: 'htmlrefpub', internal: 'htmlrefpub', default_value: '')
+ htmlrefdir = depmod.get_variable(pkgconfig: 'htmlrefdir', internal: 'htmlrefdir', default_value: '')
+ if htmlrefpub == ''
+ htmlrefpub = htmlrefdir
+ elif htmlrefdir == ''
+ htmlrefdir = htmlrefpub
+ endif
+ doxygen_tagfiles += ' "' + doxytagfile + '=' + htmlrefpub + '"'
+
+ # Doxygen <= 1.8.15
+ docinstall_flags += ['-l', doxytagfile.split('/')[-1] + '@' + htmlrefdir]
+ if htmlrefpub != htmlrefdir
+ # Doxygen >= 1.8.16
+ docinstall_flags += ['-l', 's@' + htmlrefpub + '@' + htmlrefdir]
+ endif
+ endif
+ endif
+endforeach
+
+book_name = 'lib' + sigcxx_pcname
+book_title = meson.project_name() + ' Reference Manual'
+
+# Configuration data for Doxyfile.
+doc_conf_data = configuration_data()
+doc_conf_data.set('configure_input',
+ 'docs/docs/reference/Doxyfile. Generated from Doxyfile.in by meson.configure_file().')
+doc_conf_data.set('PACKAGE_NAME', meson.project_name())
+doc_conf_data.set('PACKAGE_VERSION', meson.project_version())
+doc_conf_data.set('abs_top_builddir', built_files_root)
+doc_conf_data.set('abs_top_srcdir', project_source_root)
+doc_conf_data.set('SIGCXX_API_VERSION', sigcxx_api_version)
+doc_conf_data.set('DOXYGEN_TAGFILES', doxygen_tagfiles)
+
+doxyfile = configure_file(
+ input: 'Doxyfile.in',
+ output: '@BASENAME@',
+ configuration: doc_conf_data,
+)
+
+# Installation directories relative to {prefix}.
+install_docdir = install_datadir / 'doc' / book_name
+install_reference_docdir = install_docdir / 'reference'
+install_devhelpdir = install_datadir / 'devhelp' / 'books' / book_name
+
+if not build_documentation
+ # Documentation shall not be built or installed.
+ # Return to the calling meson.build file.
+ subdir_done()
+endif
+
+
+# Built input .h files to Doxygen.
+blt_h_files = []
+foreach file : built_h_files
+ blt_h_files += built_files_root / 'sigc++' / file
+endforeach
+
+# Hand-coded input .h files to Doxygen.
+src_h_files = []
+foreach file : source_h_files
+ src_h_files += project_source_root / 'sigc++' / file
+endforeach
+src_h_files += project_source_root / 'sigc++' / 'sigc++.h'
+
+doctool_dir = project_source_root / 'untracked' / 'docs' # MMDOCTOOLDIR
+doctool_dist_dir = 'untracked' / 'docs' # Relative to MESON_DIST_ROOT
+
+if built_h_file_targets.length() > 0
+ # .h files have been generated from .hg files (maintainer mode).
+ tag_file = custom_target('html_and_tag',
+ input: src_h_files,
+ output: book_name + '.tag',
+ command: [
+ python3, doc_reference, 'doxygen',
+ doctool_dir,
+ '@OUTPUT@',
+ blt_h_files,
+ '@INPUT@',
+ ],
+ depend_files: doxyfile,
+ depends: built_h_file_targets + doxygen_tag_targets,
+ build_by_default: build_documentation,
+ install: true,
+ install_dir: install_reference_docdir,
+ )
+else
+ # All .h files are stored in the source tree (not maintainer mode).
+ tag_file = custom_target('html_and_tag',
+ input: src_h_files + blt_h_files,
+ output: book_name + '.tag',
+ command: [
+ python3, doc_reference, 'doxygen',
+ doctool_dir,
+ '@OUTPUT@',
+ '@INPUT@',
+ ],
+ depend_files: doxyfile,
+ depends: doxygen_tag_targets,
+ build_by_default: build_documentation,
+ install: true,
+ install_dir: install_reference_docdir,
+ )
+endif
+
+devhelp_file = custom_target('devhelp',
+ input: tag_file,
+ output: book_name + '.devhelp2',
+ command: [
+ python3, doc_reference, 'devhelp',
+ doctool_dir,
+ '@INPUT@',
+ '@OUTPUT@',
+ book_name,
+ book_title,
+ ],
+ build_by_default: build_documentation,
+)
+
+# Install Devhelp file and html files.
+meson.add_install_script(
+ python3, doc_reference, 'install_doc',
+ doctool_dir,
+ devhelp_file.full_path(),
+ install_devhelpdir,
+ install_reference_docdir / 'html',
+ docinstall_flags
+)
+
+if can_add_dist_script
+ # Distribute built files and files copied by mm-common-get.
+ meson.add_dist_script(
+ python3, doc_reference, 'dist_doc',
+ doctool_dir,
+ doctool_dist_dir,
+ meson.current_build_dir(),
+ tag_file.full_path(),
+ devhelp_file.full_path(),
+ )
+endif
--- /dev/null
+web_path = /home/groups/l/li/libsigc/htdocs/
+
+post-html:
+ rsync -avz --rsh ssh --cvs-exclude * $$USER,libsigc@web.sourceforge.net:$(web_path)
+
+#post-html:
+# scp $$SSH_OPT -r *.shtml *.css fragments images $$USER@shell.sourceforge.net:$(web_path)
--- /dev/null
+<!-- SSI fragments/htm_declaration.html_fragment begin -->
+<!--#include virtual="fragments/html_declaration.html_fragment" -->
+<!-- SSI fragments/html_declaration.html_fragment end -->
+
+
+<h3>Signal System Comparison: Qt (tm) vs Libsigc++</h3><p>
+
+<a name="preface"><h3>Preface</h3></a>
+
+This comparison is by no means a fair fight. Libsigc++ can't possibly lose
+and will defeat Qt soundly. First of all, Qt and Libsigc++ have different
+design goals and thus the things measured to show the features of Libsigc++,
+may not be considerations for Qt. a excellent widget set and a program
+framework while libsigc++ is nothing more that a small component. Speed of
+signal/slot operations is not a very big consideration in most GUI code.
+Further, Qt was written several years ago, while I still have cuts in my
+fingers from feeling the bleeding edge. I am controlling the conditions of
+the tests, and thus when I find a failing in libsigc++ during the testing, I
+get to go back and fix it. On the other hand, TrollTech is concerned with
+binary compatiblity with old versions. Further, libsigc++ is a template
+library meaning all the code is specialized for each usage. On the other
+hand, Qt is a generalist using strings to store all signal information.
+This is flexible but slower.
+
+<p>
+That said there is a basis for comparison. Both libsigc++ and Qt provide
+similar functionality with their signal/slot system. They both are C++
+libraries which run under both windows and Unix. Both originated from
+widget sets and both have flexiblity and ease of use a key factors. Qt
+version 1.42 was used and Libsigc++ modified from version 0.8.0.
+<p>
+
+(Note that I have been in contact with Arnt Gulbrandsen of Troll Tech AS.
+He has discovered a problem in the Qt system than resulted in excessive time
+in the emit functions. He indicates that it should be fixed for Qt 2.0
+which will improve their performance.)
+
+<p>
+<a name="arch"><h3>String based verse Templates</h3></a>
+
+There is a significant differences between the architectures of Libsigc++
+and Qt signal system. Libsigc++ is a template based while Qt is string
+based.
+<P>
+
+String based signal systems have a number of advantages and disadvantages
+over template based. It is simpler to implement, so it should in general
+win in size and compile speed compared to the bloat of templates. As they
+don't need anything but basic C++ features, such systems are more portable
+accross systems. Any signal you want can be declared, including new signals
+at runtime. (Although Qt doesn't take advantage of this.) This is also a
+disadvantage for the approach as the compiler does not check the typesafty
+of connections until they are called at runtime. Some basic checking may be
+done, but in general it is minimal. Often this approach requires a
+preprocessor to hide the string nature and do such checking.
+<p>
+
+Template based on the other hand is entirely different beast. Everything is
+compiled in to the binary including the connections forming agents. This is
+a huge advantage that whatever compiles, runs. Beter still no precompiler
+was needed, as the whole system can be build using C++ notation. All
+typechecking is done at compile time by the compiler, thus no checking needs
+to be performed during the runtime operations. Faster running does come a
+price. All the templates generate code which will appear in the binary.
+Therefore great pains in the design of a template library are taken to hold
+this to a minumum. Further, the template capablities of different compilers
+vary wildly, so portablity is hard to achieve. These are not insurmountable
+though, as libsigc++ has excellent portablity and size. <p>
+
+
+<a name="features"><h3>Table of Features</h3></a>
+
+The following features are relevant when comparing Qt signal/slot system
+and Libsigc++.
+
+<table width="90%" border="1">
+<tr><td> Feature </td><td> Qt </td><td> Libsigc++ </td></tr>
+<tr><td> Requires no special compiler steps </td><td> No </td><td> Yes </td></tr>
+<tr><td> Protected Signals </td><td> Yes </td><td> Yes </td></tr>
+<tr><td> Public Signals </td><td> No </td><td> Yes </td></tr>
+<tr><td> Any function can be slot </td><td> No </td><td> Yes </td></tr>
+<tr><td> Void returns </td><td> Yes </td><td> Yes </td></tr>
+<tr><td> Non-void returns </td><td> No </td><td> Yes </td></tr>
+<tr><td> Reference returns </td><td> No </td><td> No </td></tr>
+<tr><td> Any type in argument list </td><td> No </td><td> Yes </td></tr>
+<tr><td> Signals in global scope </td><td> No </td><td> Yes </td></tr>
+<tr><td> Signals in class scope </td><td> Yes </td><td> Yes </td></tr>
+<tr><td> Signals in other scopes </td><td> No </td><td> Yes </td></tr>
+<tr><td> Bindable arguments </td><td> No </td><td> Yes </td></tr>
+<tr><td> Argument type conversion </td><td> No </td><td> Yes </td></tr>
+<tr><td> Return type conversion </td><td> No </td><td> Yes </td></tr>
+<tr><td> Namespace support </td><td> No </td><td> Yes </td></tr>
+<tr><td> Signal Cost (bytes) </td><td> 0 </td><td> 4 </td></tr>
+</table>
+<p>
+
+<a name="details"><h3>Feature Details</h3></a>
+Preprocessors and such generally indicate a lack of faith in the compiler
+and add an extra step in compilation. Qt does this because of its support
+for early compilers with poor template support. At this time, such things
+aren't generally required.
+<p>
+
+Public and protected refer to the access of a signal in a class. Qt can
+only emit from inside the owning class. Libsigc++ signals are normal
+objects and thus can be private, protected or public.
+<p>
+
+Void and non-void returns refer to what type a signal may return from emit.
+Qt only supports void returns. Libsigc++ supports return types of most
+kinds including building lists of return values. However, pass by reference
+still has a few bugs.
+<p>
+
+There can be some restriction on the number and type of arguments a signal
+can take. Qt does not support templates or function pointers in argument
+lists. This can be gotten arround with careful typedefs. This is a result
+of the moc preprocessor.
+<p>
+
+Signal declarations may have restrictions in the location of declaration.
+Libsigc++ signals can be declared anywhere including within templates and
+nested classes. This a big plus.
+<p>
+
+Libsigc++ supplies a set of adaptors for altering the types of slots
+including binding arguments and converting types. This is a feature that
+grew out of necessity of the gtkmm project needing to take something from a
+C type to a C++ type. It can be very useful.
+<p>
+
+Size of signals is the one place where Qt is a clear winner. Zero is a very
+attractive cost. The same effect can be achieved using libsigc++ with a
+specialized signal and a map. However, this arrangement would be slower.
+This functionality is scheduled to be added to libsigc++.
+<p>
+
+<a name="speed"><h3>Speed benchmarks</h3></a>
+
+To measure the speed of both systems, an emit was placed in a tight loop.
+The emit called a trivial function. The benchmark speed was taken to be the
+total elapsed time as measured by unix "time" minus time for the same
+program to run calling directly divided by the number of calls. Iterations
+were chosen to ensure the system ran for at least 20 seconds. Both were
+dynamically linked, stripped, and fully optimized (-03). Dynamic linked was
+tested to have insignificant effects. The benchmarking machine was a
+sluggish 133Mhz 586.
+<p>
+The number of slots was varied to determine how much of the cost is per emit
+and how much is per slot attached.
+<p>
+
+Libsigc++ could be run with either thread safe marshalling of the return
+value, skipping the return value or marshalling in a non-thread safe manner.
+The closest comparison between Qt and libsigc++ is to skip the return value,
+because Qt has no support for return types.
+
+<pre>
+libsigc++ without marshal
+=====================================================
+iterations: 2^26
+
+ 0 base 0 emit 1 base 1 emit 2 base 2 emit
+ 1.023 10.58 2.03 32.717 2.533 56.237
+
+O penalty: 140ns
+1 penalty: 460ns
+2 penalty: 800ns
+
+Emit cost: 140ns
+Slot cost: 330ns
+
+
+libsigc++ with marshal
+=====================================================
+iterations: 2^24
+
+ 0 base 0 emit 1 base 1 emit 2 base 2 emit
+ 0.27 2.93 0.52 24.04 0.65 45.48
+
+0 penalty: 160ns
+1 penalty: 1400ns
+2 penalty: 2670ns
+
+Emit cost: 160ns
+Slot cost: 1260ns
+
+
+Qt
+=====================================================
+iterations: 2^21 (0 done a 2^24 for better resolution)
+
+ 0 base 0 emit 1 base 1 emit 2 base 2 emit
+ 0.37 5.28 0.18 32.34 0.20 34.25
+ 0.37 31.82
+
+0 penalty: 1870ns (295ns shortcut)
+1 penalty: 15300ns
+2 penalty: 16200ns
+
+Emit cost: 1800ns-15300ns
+ (varies with number of signals/slot attached.)
+Slot cost: 900ns
+
+</pre>
+Because Qt shares a data structure for all signal lists,
+the times for an emit are hard to calculate. In general
+the more signals connected the longer it took to find the
+data needed to emit the slot, increasing the emit cost.
+As very small numbers of connects were tested, it is not
+clear how high this cost can go. (Libsigc++ is
+more direct in approach, so one can calculate purely
+by multiplying up the frequencies by the costs.)
+<p>
+
+Qt does a short cut for emitting signals when no connections
+have been established yet
+which gives a massive speed up to emit time. However,
+as the general case will have at least one signal connected
+somewhere in the object, this is not representative.
+If there is at least one slot connected to the signal, a 15ms
+time delay is paid. This would be a good area in Qt for improvement.
+<p>
+
+In a direct comparison, libsigc++ is 30 times faster for emiting
+one connected signal. Thread safe
+marshalling of the return values increase emit penalty by 3, which
+still is a order of magnitude faster that Qt for emitting a
+signal with one slot. The per slot cost of without marshalling of
+return values is only 3 times slowing in Qt then libsigc++, and
+comparable with the marshaller. However, the initial startup
+cost dominates over all others. So as far as speed is concerned,
+libsigc++ is clearly better.
+<p>
+
+<a name="size"><h3>Binary size</h3></a>
+
+To show that libsigc++ is not taking advantage of its templates to
+specialize every detail at the cost of a huge binary, the size of the
+benchmarking programs was compared. Both were striped and dynamically
+linked.
+
+<pre>
+Libsigc++: 5456 bytes
+Qt: 6020 bytes
+</pre>
+
+The binary sizes are comparable with a slight edge to libsigc++. As the
+programs are very small, it should not be assumed that this trend holds as
+number of signals increases.
+<p>
+
+<a name="compile"><h3>Compile time</h3></a>
+
+Another major concern with Libsigc++ is that its hundreds of templates are
+likely going to take most compilers to its knees. This is a very valid
+concern. So I measured the time of compiling the benchmark programs
+
+<pre>
+Libsigc++: 0:02.62
+Qt: 0:03.09
+</pre>
+
+Again, there is a slight edge to Libsigc++. This at least means that
+libsigc++ is not completely out of the ballpark at slow compiles. Again one
+should not assume this holds for very large programs.
+<p>
+
+<a name="analysis"><h3>Final Analysis</h3></a>
+
+As expected libsigc++ beat Qt's signal system hands down. It was an order
+of magnitude faster with no significant cost to binary size and compile
+time. It is slightly larger on the size of objects which may be a concern
+if hundreds of signals are used. An excellent start for a free library!
+
+<P>
+<a name="references"><h3>References</h3></a>
+
+<ul>
+ <li><a href="http://www.troll.no/qt/metaobjects.html">Signals, Slots and the Meta Object Compiler</a></li>
+ <li><a href="http://www.troll.no/qt/moc.html">Using the Meta Object Compiler</a></li>
+</ul>
+<p>
+tm - Qt is a trademark of Troll Tech As of Norway.
+
+
+
+<!-- SSI fragments/footer.html_fragment begin -->
+<!--#include virtual="fragments/footer.html_fragment" -->
+<!-- SSI fragments/footer.html_fragment begin -->
--- /dev/null
+<!-- SSI fragments/htm_declaration.html_fragment begin -->
+<!--#include virtual="fragments/html_declaration.html_fragment" -->
+<!-- SSI fragments/html_declaration.html_fragment end -->
+
+<a name="devel"><h2>Development</h2></a>
+
+
+<a name="mail"><h3>Mailing List</h3></a>
+
+<p>
+There is a mailing list,
+<a href="http://mail.gnome.org/mailman/listinfo/libsigc-list">libsigc-list@gnome.org</a> for Libsigc++, to serve as
+a design discussion area as well as a place to report bugs. To subscribe, use the web
+<a href="http://mail.gnome.org/mailman/listinfo/libsigc-list">page</a>.
+Members can post directly, but all other traffic is moderated.
+There is an archive of messages,
+<a href="http://mail.gnome.org/archives/libsigc-list/">here</a>.
+</p>
+
+<a name="patches"><h3>Patches</h3></a>
+
+<p>
+Patches should be added to GitHub's issue tracker.</p>
+
+<p>
+Open <a href="https://github.com/libsigcplusplus/libsigcplusplus/issues">libsigc++ issues</a>.
+</p>
+
+<a name="git"><h3>Version Control</h3></a>
+
+<p>
+libsigc++ is in the <a href="https://github.com/libsigcplusplus/libsigcplusplus">libsigcplusplus</a> module in GitHub's git repository.
+</p>
+
+<!-- SSI fragments/footer.html_fragment begin -->
+<!--#include virtual="fragments/footer.html_fragment" -->
+<!-- SSI fragments/footer.html_fragment end -->
--- /dev/null
+<!-- SSI fragments/htm_declaration.html_fragment begin -->
+<!--#include virtual="fragments/html_declaration.html_fragment" -->
+<!-- SSI fragments/html_declaration.html_fragment end -->
+
+<a name="doc"><h3>Documentation</h3></a>
+
+<p>
+We have both <a href="http://developer.gnome.org/libsigc++-tutorial/stable/">tutorial-style</a>
+and <a href="http://developer.gnome.org/libsigc++/stable/">reference</a> documentation.</p>
+
+
+<a name="glossary"><h3>Glossary of terms</h3></a>
+<p>
+For those which just want a quick look at the terms used in
+the system, glance over the <a href="glossary.shtml">glossary</a>
+</p>
+
+
+<!-- SSI fragments/footer.html_fragment begin -->
+<!--#include virtual="fragments/footer.html_fragment" -->
+<!-- SSI fragments/footer.html_fragment end -->
--- /dev/null
+</div>
+<hr></hr>
+<div class="right">
+
+<a href="mailto:libsigc-list@gnome.org">libsigc++ mailing list</a>
+ |
+<a href="https://github.com/libsigcplusplus/libsigcplusplus/">website source</a>
+ |
+<a href="http://sourceforge.net">
+<img src="http://sourceforge.net/sflogo.php?group_id=1970&type=1" alt="*SOURCEFORGE*" width="88" height="31" border="0" /></a>
+
+<a href="http://validator.w3.org/check/referer"><img
+src="http://validator.w3.org/images/vxhtml11"
+alt="Valid XHTML 1.0!" height="31" width="88" border="0" /></a>
+
+</div>
+</body>
+</html>
--- /dev/null
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+<html>
+ <head>
+ <title>libsigc++ -- The Typesafe Callback Framework for C++</title>
+ <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+ <link rel="stylesheet" href="style.css" type="text/css" />
+ </head>
+ <body>
+
+ <div id="rightbox">
+
+ <div id="coloredbox">
+
+ <a class="menu" href="index.shtml">Main</a><br />
+
+ <a class="menu" href="index.shtml#features">Features</a><br />
+
+ <a class="menu" href="license.shtml">License</a><br />
+ <br />
+ <a class="menu" href="doc.shtml">Documentation</a><br />
+
+ <a class="menu" href="stable.shtml">Download</a><br />
+ <br />
+ <a class="menu" href="devel.shtml#mail">Mailing List</a><br />
+
+ <a class="menu" href="devel.shtml#patches">Patches</a><br />
+
+ <a class="menu" href="devel.shtml#git">Git</a><br />
+ <br />
+ <a class="menu" href="link.shtml">Links</a><br />
+
+ </div>
+
+ </div>
+
+ <div id="contents">
+ <table border="0" width="90%" cellpadding="0">
+ <tr>
+ <td><img src="pix/logo.gif" width="280" height="85" alt="libsigc++" /></td>
+ <td align="center">
+ <b>Callback Framework for C++</b>
+ </td>
+ </tr>
+ </table>
+
+ <hr></hr>
--- /dev/null
+<!-- SSI fragments/htm_declaration.html_fragment begin -->
+<!--#include virtual="fragments/html_declaration.html_fragment" -->
+<!-- SSI fragments/html_declaration.html_fragment end -->
+
+
+<a name="index"><h3>Glossary of Terms</h3></a>
+
+<p><b>adaptor</b> <i>(noun)</i> - A function which alters a slot’s
+signature. </p>
+
+<p><b>bind</b> <i>(verb)</i> - To fix a value of a callback's argument in the
+STL sense. </p>
+
+<p><b>call</b> <i>(verb)</i> - The process of invoking a callback or slot. </p>
+
+<p><b>callback</b> <i>(noun)</i> - 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. </p>
+
+<p><b>connect</b> <i>(verb)</i> - The process of specifying the callback
+which will be called when the signal is emitted. </p>
+
+<p><b>emit</b> <i>(verb)</i> - When a signal is emitted, the connected slots
+will be called. </p>
+
+<p><b>factory</b> <i>(noun)</i> - A function which takes a set of arguments and
+produces a different object based on those arguments. </p>
+
+<p><b>handle</b> <i>(noun)</i> - A safe version of a pointer. </p>
+
+<p><b>marshaller</b> <i>(noun)</i> - 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. </p>
+
+<p><b>safe</b> <i>(adj)</i> - 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. </p>
+
+<p><b>signal</b> <i>(noun)</i> - 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.
+</p>
+
+<p><b>signal handler</b> <i>(noun)</i> - Another name for a callback. </p>
+
+<p><b>signature</b> <i>(noun)</i> - The return type of a function together with
+the argument types of that function. </p>
+
+<p><b>slot</b> <i>(noun)</i> - A safe version of a callback. </p>
+
+<!-- SSI fragments/footer.html_fragment begin -->
+<!--#include virtual="fragments/footer.html_fragment" -->
+<!-- SSI fragments/footer.html_fragment begin -->
--- /dev/null
+<!-- SSI fragments/htm_declaration.html_fragment begin -->
+<!--#include virtual="fragments/html_declaration.html_fragment" -->
+<!-- SSI fragments/html_declaration.html_fragment end -->
+
+
+<a name="about"><h3>About</h3></a>
+<p>
+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.
+</p>
+<p>
+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, <a href="http://www.gnu.org/copyleft/lgpl.html">LGPL</a>.
+</p>
+<p>
+<a name="features"><h3>Features</h3></a>
+<ul>
+ <li>Compile time typesafe callbacks (faster than run time checks)</li>
+ <li>Typesafety violations report line number correctly with
+ template names (no tracing template failures into headers)</li>
+ <li>No compiler extensions or meta compilers required</li>
+ <li>Proper handling of dynamic objects and signals
+ (deleted objects will not cause seg faults)</li>
+ <li>Extendable API at any level:
+ signal, slot, connection and trackable</li>
+ <li>Extensions do not require alteration of basic components</li>
+ <li>User definable accumulators</li>
+ <li>A variety of adaptors to change the callback signature:
+ bind, hide, retype, compose</li>
+ <li>Most C++ compilers can be used. libsigc++ version 2.5.1 and later require
+ a compiler with C++11 support</li>
+</ul>
+</p>
+<p>
+<a name="news"><h3>News</h3></a>
+
+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:
+<ul>
+ <li>Provides unnumbered signal and slot templates.</li>
+ <li>Supports arbitrary functor types.</li>
+ <li>Supports implicit argument type conversions on signal emission.</li>
+ <li>Adds support for overloaded functions.</li>
+ <li>Borrows powerful accumulator interface from boost::signal.</li>
+ <li>Simplifies use of adaptors like sigc::hide(): argument types need
+ not be specified any more (except for sigc::retype_return()).</li>
+ <li>More powerful adaptors: position of arguments to hide or bind can
+ be chosen freely; up to 7 arguments can be bound at a time.</li>
+ <li>Adds two useful adaptors: sigc::compose(), sigc::exception_catch().</li>
+ <li>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.</li>
+ <li>Conforms to the STL naming scheme: only uses small letters.</li>
+ <li>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.</li>
+</ul>
+</p>
+
+<p>
+Also good to check out are the <a href=
+ "http://www.erikyyy.de/sigslot/">Erik Thiele</a> and <a href=
+ "http://ucxx.sourceforge.net/">Andreas Rottmann</a> sites which
+include some interesting libsigc++ tools like cross-thread support.
+</p>
+
+<p>
+<a name="devel"><h3>Developers</h3></a>
+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.
+</p>
+
+<!-- SSI fragments/footer.html_fragment begin -->
+<!--#include virtual="fragments/footer.html_fragment" -->
+<!-- SSI fragments/footer.html_fragment end -->
--- /dev/null
+
+<!-- SSI fragments/htm_declaration.html_fragment begin -->
+<!--#include virtual="fragments/html_declaration.html_fragment" -->
+<!-- SSI fragments/html_declaration.html_fragment end -->
+
+
+<p>
+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.
+</p>
+
+<p>
+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.
+</p>
+
+<p>
+<hr>
+
+<pre>
+ 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.
+\f
+ 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.
+\f
+ 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.
+\f
+ 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.
+\f
+ 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.
+\f
+ 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.
+\f
+ 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.
+\f
+ 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.
+\f
+ 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
+\f
+ 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.
+
+ <one line to give the library's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ 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.
+
+ <signature of Ty Coon>, 1 April 1990
+ Ty Coon, President of Vice
+
+That's all there is to it!
+
+</pre>
+<!-- SSI fragments/footer.html_fragment begin -->
+<!--#include virtual="fragments/footer.html_fragment" -->
+<!-- SSI fragments/footer.html_fragment begin -->
--- /dev/null
+<!-- SSI fragments/htm_declaration.html_fragment begin -->
+<!--#include virtual="fragments/html_declaration.html_fragment" -->
+<!-- SSI fragments/html_declaration.html_fragment end -->
+
+<a name="gnome"><h3>GNOME Links</h3></a>
+
+<p>
+Libsigc++ is part of the greater GNOME code base.
+<ul>
+ <li><a href="http://www.gtkmm.org">gtkmm widget wrapper</a></li>
+ <li><a href="http://www.gtk.org">GTK+ widget set</a></li>
+ <li><a href="http://www.gnome.org">Gnome project</a></li>
+</ul>
+</p>
+
+<a name="other"><h3>Callback Links</h3></a>
+
+<p>
+There are a number of other C++ callback systems
+and publications on construction of callback systems.
+<ul>
+ <li><a href="http://www.boost.org/doc/html/signals.html">Boost Signals</a></li>
+ <li>Trolltech signal system (part of <a href="http://www.qt.io/">Qt widget set</a>)</li>
+ <li>(Send us a link you find worth mentioning here.)</li>
+</ul>
+</p>
+
+<a name=""><h3>Users</h3></a>
+
+<p>
+Here is a list of some of the projects that use libsigc++.
+(Have a project which is using libsigc++? Mail us.)
+<ul>
+ <li><a href="http://www.gtkmm.org">glibmm and gtkmm</a></li>
+ <li><a href="http://sourceforge.net/projects/libpropc/">Libpropc++: Creating
+and effective using properties in C++</a></li>
+ <li><a href="http://ucxx.sourceforge.net/">Yehia: Extension library with support for cross-threaded signal emission.</a></li>
+ <li><a href="http://gfc.sourceforge.net/">GFC: Alternative C++ wrapper for the GTK+ widget set.</a></li>
+ <li><a href="http://sourceforge.net/projects/libuta/">Libuta</a></li>
+ <li><a href="http://www.worldforge.org/">The WorldForge Project</a></li>
+</ul>
+</p>
+
+<!-- SSI fragments/footer.html_fragment begin -->
+<!--#include virtual="fragments/footer.html_fragment" -->
+<!-- SSI fragments/footer.html_fragment end -->
--- /dev/null
+<!-- SSI fragments/htm_declaration.html_fragment begin -->
+<!--#include virtual="fragments/html_declaration.html_fragment" -->
+<!-- SSI fragments/html_declaration.html_fragment end -->
+
+<a name="download"><h2>Download</h2></a>
+
+<a name="sources"><h3>Source Packages</h3></a>
+
+<p>
+The source packages for libsigc++ are available on the <a href="http://ftp.gnome.org/pub/GNOME/sources/libsigc++/">GNOME ftp site</a>
+and via the <a href="http://download.gnome.org/sources/libsigc++/">GNOME download site</a>.
+</p>
+
+<a name="binaries"><h3>Binary Packages</h3></a>
+
+<p>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.</p>
+
+<a name="require"><h3>Requirements</h3></a>
+
+<a href="http://www.freedesktop.org/wiki/Software/pkg-config/">pkg-config</a> should be used to build software that depends on libsigc++.
+
+<p>
+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.
+</p>
+
+<!-- SSI fragments/footer.html_fragment begin -->
+<!--#include virtual="fragments/footer.html_fragment" -->
+<!-- SSI fragments/footer.html_fragment end -->
--- /dev/null
+body {
+ background-color: #F7F7F7;
+ font-family: Verdana, Arial, Helvetica, sans-serif;
+}
+
+#rightbox {
+ float: right;
+ margin-top: 50px;
+ width: 180px;
+}
+
+#coloredbox {
+ background-color: #6299cd;
+ padding: 5px;
+ border: 2px solid black;
+
+}
+
+a.menu { text-decoration: underline; color: white; }
+a.menu:link { text-decoration: underline; color: white; }
+a.menu:visited { text-decoration: underline; color: white; }
+a.menu:hover { text-decoration: none; }
+
+.right {
+ text-align: right;
+}
+
+#contents {
+ margin-right: 190px;
+
+}
+
--- /dev/null
+## Copyright (c) 2009 Openismus GmbH <http://www.openismus.com/>
+##
+## This file is part of libsigc++.
+##
+## libsigc++ 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.
+##
+## libsigc++ 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 <http://www.gnu.org/licenses/>.
+
+AM_CPPFLAGS = -I$(top_builddir) -I$(top_srcdir)
+AM_CXXFLAGS = $(SIGC_WXXFLAGS) -DSIGCXX_DISABLE_DEPRECATED
+LDADD = $(top_builddir)/sigc++/libsigc-$(SIGCXX_API_VERSION).la
+
+noinst_PROGRAMS = hello_world member_method
+
+hello_world_SOURCES = hello_world.cc
+member_method_SOURCES = member_method.cc
--- /dev/null
+/* Copyright 2003, The libsigc++ Development Team
+ *
+ * Assigned to the public domain. Use as you wish without
+ * restriction.
+ */
+
+#include <iostream>
+#include <string>
+
+#include <sigc++/sigc++.h>
+
+void on_print(const std::string& str)
+{
+ std::cout << str;
+}
+
+int main()
+{
+ sigc::signal<void, const std::string&> signal_print;
+
+ signal_print.connect( sigc::ptr_fun(&on_print) );
+
+ signal_print.emit("hello world\n");
+
+ return 0;
+}
--- /dev/null
+/* Copyright 2003, The libsigc++ Development Team
+ *
+ * Assigned to the public domain. Use as you wish without
+ * restriction.
+ */
+
+#include <iostream>
+#include <string>
+
+#include <sigc++/sigc++.h>
+
+class Something : public sigc::trackable
+{
+public:
+ Something();
+
+protected:
+
+ virtual void on_print(int a);
+
+ typedef sigc::signal<void, int> type_signal_print;
+ type_signal_print signal_print;
+
+};
+
+Something::Something()
+{
+ auto iter = 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.
+}
+
+void Something::on_print(int a)
+{
+ std::cout << "on_print recieved: " << a << std::endl;
+}
+
+int main()
+{
+ Something something;
+ return 0;
+}
--- /dev/null
+# 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',
+ dependencies: sigcxx_own_dep,
+ implicit_include_directories: false,
+ build_by_default: build_examples
+ )
+endforeach
--- /dev/null
+<Project xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+ xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
+ xmlns:foaf="http://xmlns.com/foaf/0.1/"
+ xmlns:gnome="http://api.gnome.org/doap-extensions#"
+ xmlns="http://usefulinc.com/ns/doap#">
+
+ <name xml:lang="en">libsigc++</name>
+ <shortdesc xml:lang="en">Typesafe callback framework for C++</shortdesc>
+ <description>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 also used by glibmm and gtkmm to wrap Glib and GTK+ signals.</description>
+ <homepage rdf:resource="https://libsigcplusplus.github.io/libsigcplusplus/" />
+ <bug-database rdf:resource="https://github.com/libsigcplusplus/libsigcplusplus/issues/" />
+ <mailing-list rdf:resource="mailto:libsigc-list@gnome.org" />
+ <category rdf:resource="http://api.gnome.org/doap-extensions#core" />
+ <programming-language>C++</programming-language>
+ <download-page rdf:resource="http://download.gnome.org/sources/libsigc++/" />
+
+ <maintainer>
+ <foaf:Person>
+ <foaf:name>Murray Cumming</foaf:name>
+ <foaf:mbox rdf:resource="mailto:murrayc@murrayc.com" />
+ <gnome:userid>murrayc</gnome:userid>
+ </foaf:Person>
+ </maintainer>
+ <maintainer>
+ <foaf:Person>
+ <foaf:name>Kjell Ahlstedt</foaf:name>
+ <foaf:mbox rdf:resource="mailto:kjellahlstedt@gmail.com" />
+ <gnome:userid>kjellahl</gnome:userid>
+ </foaf:Person>
+ </maintainer>
+</Project>
--- /dev/null
+# This file is part of libsigc++.
+
+project('libsigc++', 'cpp',
+ version: '2.10.8',
+ license: 'LGPLv2.1+',
+ default_options: [
+ 'cpp_std=c++11',
+ 'warning_level=0',
+ ],
+ meson_version: '>= 0.55.0', # required for meson.add_dist_script(python3, ...)
+ # and meson.add_install_script(python3, ...)
+)
+
+sigcxx_api_version = '2.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])]
+
+# Use these instead of meson.source_root() and meson.build_root() in subdirectories.
+# source_root() and build_root() are not useful, if this is a subproject.
+project_source_root = meson.current_source_dir()
+project_build_root = meson.current_build_dir()
+
+cpp_compiler = meson.get_compiler('cpp')
+is_msvc = cpp_compiler.get_id() == 'msvc'
+python3 = import('python').find_installation()
+
+python_version = python3.language_version()
+python_version_req = '>= 3.5'
+if not python_version.version_compare(python_version_req)
+ error('Requires Python @0@, found @1@.'.format(python_version_req, python_version))
+endif
+
+# Do we build from a git repository?
+# Suppose we do if and only if a '.git' directory or file exists.
+cmd_py = '''
+import os
+import sys
+sys.exit(os.path.isdir("@0@") or os.path.isfile("@0@"))
+'''.format(project_source_root / '.git')
+is_git_build = run_command(python3, '-c', cmd_py, 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".')
+ warning_level = get_option('dist-warnings')
+else
+ warning_level = get_option('warnings')
+endif
+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')
+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()
+
+# We must have Visual Studio 2015 or later...
+if is_msvc and cpp_compiler.version().version_compare('<19')
+ error('Visual Studio 2015 or later 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' +
+ '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
+m4 = find_program('m4', required: maintainer_mode) # For building C++ code
+doxygen = find_program('doxygen', required: build_documentation)
+dot = find_program('dot', required: build_documentation) # Used by Doxygen
+xsltproc = find_program('xsltproc', required: build_documentation)
+
+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.
+ run_command(mm_common_get, '--force', script_dir,
+ project_source_root / 'untracked' / 'docs',
+ check: true,
+ )
+else
+ cmd_py = '''
+import os
+import sys
+sys.exit(os.path.isfile("@0@"))
+'''.format(doc_reference)
+ file_exists = run_command(python3, '-c', cmd_py, check: false).returncode() != 0
+ if not file_exists
+ warning('Missing files in untracked/. You may have to enable maintainer-mode.')
+ endif
+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.
+warning_flags = []
+if warning_level == 'min'
+ if is_msvc
+ warning_flags = ['/W3']
+ else
+ warning_flags = ['-Wall']
+ endif
+elif warning_level == 'max' or warning_level == 'fatal'
+ if is_msvc
+ warning_flags = ['/W4']
+ else
+ warning_flags = '-pedantic -Wall -Wextra -Wsuggest-override -Wshadow -Wzero-as-null-pointer-constant -Wformat-security'.split()
+ endif
+ if warning_level == 'fatal'
+ if is_msvc
+ warning_flags += ['/WX']
+ else
+ warning_flags += ['-Werror']
+ endif
+ 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.
+if is_msvc
+ foreach wd : ['/FImsvc_recommended_pragmas.h', '/EHsc', '/wd4267']
+ disabled_warning = cpp_compiler.get_supported_arguments(wd)
+ add_project_arguments(disabled_warning, language: 'cpp')
+ endforeach
+endif
+
+# Configure files
+pkg_conf_data = configuration_data()
+pkg_conf_data.set('prefix', install_prefix)
+pkg_conf_data.set('exec_prefix', '${prefix}')
+pkg_conf_data.set('libdir', '${exec_prefix}' / install_libdir)
+pkg_conf_data.set('datarootdir', '${prefix}' / install_datadir)
+pkg_conf_data.set('datadir', '${datarootdir}')
+pkg_conf_data.set('includedir', '${prefix}' / install_includedir)
+pkg_conf_data.set('top_srcdir', project_source_root)
+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', true)
+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)
+foreach conf_test : ['gcc_template_specialization_operator_overload',
+ 'msvc_template_specialization_operator_overload',
+ 'have_sun_reverse_iterator',
+ 'pragma_push_pop_macro']
+ if cpp_compiler.compiles(files('tools' / conf_test + '.cc'))
+ pkg_conf_data.set('SIGC_' + conf_test.to_upper(), true)
+ endif
+endforeach
+
+configure_file(
+ input: 'sigc++.pc.in',
+ output: sigcxx_pcname + '.pc',
+ configuration: pkg_conf_data,
+ install_dir: install_pkgconfigdir,
+)
+
+configure_file(
+ input: 'sigc++-uninstalled.pc.in',
+ output: sigcxx_pcname + '-uninstalled.pc',
+ configuration: pkg_conf_data,
+)
+
+install_includeconfigdir = install_libdir / sigcxx_pcname / 'include'
+sigcxxconfig_h = configure_file(
+ input: 'sigc++config.h.meson',
+ output: 'sigc++config.h',
+ configuration: pkg_conf_data,
+ install_dir: install_includeconfigdir,
+)
+
+# add_dist_script() is not allowed in a subproject if meson.version() < 0.58.0.
+can_add_dist_script = not meson.is_subproject() or meson.version().version_compare('>= 0.58.0')
+
+subdir('MSVC_NMake')
+subdir('sigc++')
+subdir('examples')
+subdir('tests')
+subdir('docs/reference')
+subdir('docs/manual')
+
+if can_add_dist_script
+ # Add a ChangeLog file to the distribution directory.
+ meson.add_dist_script(
+ python3, dist_changelog,
+ project_source_root,
+ )
+ # 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',
+ )
+endif
+
+if meson.is_subproject()
+ pkgconfig_vars = {
+ 'htmlrefdir': install_prefix / install_docdir / 'reference' / 'html',
+ 'htmlrefpub': 'http://library.gnome.org/devel/libsigc++/2.10/'
+ }
+ 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
+
+validate = get_option('validation') and can_parse_and_validate
+explain_val = ''
+if get_option('validation') and not validate
+ explain_val = ' (requires xmllint with Relax NG and DocBook V5.0 support)'
+endif
+
+build_pdf = build_pdf_by_default and can_build_pdf
+explain_pdf = ''
+if build_pdf_by_default and not build_pdf
+ explain_pdf = ' (requires dblatex or (xsltproc and fop))'
+endif
+
+summary = [
+ '',
+ '------',
+ meson.project_name() + ' ' + meson.project_version(),
+ '',
+ ' Maintainer mode: @0@@1@'.format(maintainer_mode_opt, real_maintainer_mode),
+ ' Compiler warnings: @0@'.format(warning_level),
+ ' Build deprecated API: @0@'.format(build_deprecated_api),
+ 'Build HTML documentation: @0@@1@'.format(build_documentation_opt, real_build_documentation),
+ ' XML validation: @0@@1@'.format(validate, explain_val),
+ ' Build PDF: @0@@1@'.format(build_pdf, explain_pdf),
+ ' Build example programs: @0@'.format(build_examples),
+ ' 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))
--- /dev/null
+option('maintainer-mode', type: 'combo', choices: ['false', 'if-git-build', 'true'],
+ value: 'if-git-build', description: 'Generate source code from .m4 files')
+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('validation', type: 'boolean', value: true,
+ description: 'Validate the tutorial XML file')
+option('build-pdf', type: 'boolean', value: false,
+ description: 'Build tutorial PDF file')
+option('build-examples', type: 'boolean', value: true,
+ description: 'Build example programs')
+option('benchmark', type: 'boolean', value: false,
+ description: 'Build and test benchmark program')
--- /dev/null
+doxytagfile=${pc_top_builddir}/docs/reference/libsigc++-@SIGCXX_API_VERSION@.tag
+htmlrefpub=http://library.gnome.org/devel/libsigc++/2.10/
+
+Name: libsigc++
+Description: Typesafe signal and callback system for C++, not installed
+Version: @PACKAGE_VERSION@
+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@
--- /dev/null
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+datarootdir=@datarootdir@
+datadir=@datadir@
+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++/2.10/
+
+Name: libsigc++
+Description: Typesafe signal and callback system for C++
+Version: @PACKAGE_VERSION@
+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
--- /dev/null
+## Copyright (c) 2009 Openismus GmbH <http://www.openismus.com/>
+##
+## This file is part of libsigc++.
+##
+## libsigc++ 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.
+##
+## libsigc++ 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 <http://www.gnu.org/licenses/>.
+
+AUTOMAKE_OPTIONS = subdir-objects
+
+include $(srcdir)/filelist.am
+
+# Subdirectories needed also in the build dir
+build_subdirs = functors adaptors/lambda
+
+dist_noinst_DATA = $(sigc_m4)
+
+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 = $(sigc_sources_cc)
+
+EXTRA_libsigc_@SIGCXX_API_VERSION@_la_SOURCES = $(sigc_built_cc)
+
+# http://www.gnu.org/software/libtool/manual/html_node/Updating-version-info.html
+libsigc_@SIGCXX_API_VERSION@_la_LDFLAGS = -no-undefined -version-info 0:0:0
+
+AM_CPPFLAGS = -I$(top_builddir) -I$(top_srcdir)
+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) $@
+
+signal.cc: \
+ signal.h \
+ signal_base.h \
+ functors/slot.h \
+ functors/slot_base.h \
+ 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 $< >$@
--- /dev/null
+// -*- 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
+ *
+ */
+#ifndef _SIGC_ADAPTOR_HPP_
+#define _SIGC_ADAPTOR_HPP_
+
+#include <sigc++/adaptors/bind.h>
+#include <sigc++/adaptors/bind_return.h>
+#include <sigc++/adaptors/hide.h>
+#include <sigc++/adaptors/retype_return.h>
+#include <sigc++/adaptors/retype.h>
+#include <sigc++/adaptors/compose.h>
+#include <sigc++/adaptors/exception_catch.h>
+#include <sigc++/adaptors/track_obj.h>
+
+#endif /* _SIGC_ADAPTOR_HPP_ */
--- /dev/null
+/*
+ * Copyright 2005, 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
+ */
+
+#ifndef _SIGC_BOUND_ARGUMENT_H_
+#define _SIGC_BOUND_ARGUMENT_H_
+
+
+#include <sigc++/limit_reference.h>
+#include <sigc++/reference_wrapper.h>
+
+
+namespace sigc {
+
+/** A bound_argument<Foo> 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<Bar>) 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<Bar>)
+ * 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
+ * stores a cop of that value, and both invoke() and visit() simply return it.
+ *
+ * This object is used by the bind_functor<> and bind_return_functor<> objects,
+ * depending on whether the argument is bound as a parameter or as a return value.
+ *
+ * The general template implementation is used for parameters that are passed by value.
+ * @e T_type The type of the bound argument.
+ */
+template <class T_type>
+class bound_argument
+{
+public:
+ /** Constructor.
+ * @param _A_argument The argument to bind.
+ */
+ bound_argument(const T_type& _A_argument)
+ : visited_(_A_argument)
+ {}
+
+ /** Retrieve the entity to visit in visit_each().
+ * @return The bound argument.
+ */
+ 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_; }
+
+private:
+ /** The value of the argument.
+ */
+ T_type visited_;
+};
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+
+//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.
+ * @e T_wrapped The type of the bound argument.
+ */
+template <class T_wrapped>
+class bound_argument< reference_wrapper<T_wrapped> >
+{
+public:
+ /** Constructor.
+ * @param _A_argument The argument to bind.
+ */
+ bound_argument(const reference_wrapper<T_wrapped>& _A_argument)
+ : visited_(unwrap(_A_argument))
+ {}
+
+ /** Retrieve the entity to visit in visit_each().
+ * @return The limited_reference to the bound argument.
+ */
+ inline const limit_reference<T_wrapped>& 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(); }
+
+private:
+ /** The limited_reference to the bound argument.
+ */
+ limit_reference<T_wrapped> visited_;
+};
+
+/** bound_argument object for a bound argument that is passed by bind() or
+ * returned by bind_return() by const reference, specialized for const reference_wrapper<> types.
+ * - @e T_wrapped The type of the bound argument.
+ */
+template <class T_wrapped>
+class bound_argument< const_reference_wrapper<T_wrapped> >
+{
+public:
+ /** Constructor.
+ * @param _A_argument The argument to bind.
+ */
+ bound_argument(const const_reference_wrapper<T_wrapped>& _A_argument)
+ : visited_(unwrap(_A_argument))
+ {}
+
+ /** Retrieve the entity to visit in visit_each().
+ * @return The const_limited_reference to the bound argument.
+ */
+ inline const const_limit_reference<T_wrapped>& 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(); }
+
+private:
+ /** The const_limited_reference to the bound argument.
+ */
+ const_limit_reference<T_wrapped> visited_;
+};
+
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+//Template specialization:
+/** bound_argument object for a bound argument that is passed by bind() or
+ * returned by bind_return() by reference, specialized for std::reference_wrapper<> types.
+ * @e T_wrapped The type of the bound argument.
+ */
+template <class T_wrapped>
+class bound_argument< std::reference_wrapper<T_wrapped> >
+{
+public:
+ /** Constructor.
+ * @param _A_argument The argument to bind.
+ */
+ bound_argument(const std::reference_wrapper<T_wrapped>& _A_argument)
+ : visited_(unwrap(_A_argument))
+ {}
+
+ /** Retrieve the entity to visit in visit_each().
+ * @return The limited_reference to the bound argument.
+ */
+ inline const limit_reference<T_wrapped>& 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(); }
+
+private:
+ /** The limited_reference to the bound argument.
+ */
+ limit_reference<T_wrapped> visited_;
+};
+
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+/** Implementation of visitor<>::do_visit_each<>() specialized for the bound_argument class.
+ * Call visit_each() on the entity returned by the bound_argument's visit()
+ * 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.
+ */
+template <class T_type>
+struct visitor<bound_argument<T_type> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_argument<T_type>& _A_argument)
+ {
+ sigc::visit_each(_A_action, _A_argument.visit());
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+} /* namespace sigc */
+
+
+#endif /* _SIGC_BOUND_ARGUMENT_H_ */
--- /dev/null
+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 <LOOP(class T_arg%1, $1)>
+ typename deduce_result_type<LOOP(T_arg%1,$1)>::type
+ operator ()(LOOP(T_arg%1 _A_%1, $1)) const
+ { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<LOOP(_P_(T_arg%1), $1)>
+ (LOOP(_A_%1, $1));
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <LOOP(class T_arg%1, $1)>
+ typename deduce_result_type<LOOP(T_arg%1,$1)>::type
+ sun_forte_workaround(LOOP(T_arg%1 _A_%1, $1)) const
+ { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<LOOP(_P_(T_arg%1), $1)>
+ (LOOP(_A_%1, $1));
+ }
+ #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+])dnl
+define([LAMBDA_DO_VALUE],[dnl
+ template <LOOP(class T_arg%1, $1)>
+ result_type operator ()(LOOP(T_arg%1, $1)) const
+ { return value_; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <LOOP(class T_arg%1, $1)>
+ 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 <sigc++/adaptors/adaptor_trait.h>
+#include <sigc++/reference_wrapper.h>
+#include <type_traits>
+
+_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 <class T_type> 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 <class T_type, bool I_islambda = std::is_base_of<lambda_base, T_type>::value> struct lambda_core;
+
+/** Abstracts lambda functionality (template specialization for lambda values).
+ *
+ * @deprecated Use C++11 lambda expressions instead.
+ *
+ * @ingroup lambdas
+ */
+template <class T_type>
+struct lambda_core<T_type, true> : public lambda_base
+{
+ template <LOOP(class T_arg%1=void,CALL_SIZE)>
+ struct deduce_result_type
+ { typedef typename T_type::template deduce_result_type<LOOP(_P_(T_arg%1),CALL_SIZE)>::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<subscript> and other<assign>
+template <class T_type>
+struct other;
+struct subscript;
+struct assign;
+
+template <class T_action, class T_type1, class T_type2>
+struct lambda_operator;
+
+template <class T_type>
+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 <class T_type>
+struct lambda : public internal::lambda_core<T_type>
+{
+ typedef lambda<T_type> self;
+
+ lambda()
+ {}
+
+ lambda(typename type_trait<T_type>::take v)
+ : internal::lambda_core<T_type>(v)
+ {}
+
+ // operators for other<subscript>
+ template <class T_arg>
+ lambda<lambda_operator<other<subscript>, self, typename unwrap_lambda_type<T_arg>::type> >
+ operator [[]] (const T_arg& a) const
+ { typedef lambda_operator<other<subscript>, self, typename unwrap_lambda_type<T_arg>::type> lambda_operator_type;
+ return lambda<lambda_operator_type>(lambda_operator_type(this->value_, unwrap_lambda_value(a))); }
+
+ // operators for other<assign>
+ template <class T_arg>
+ lambda<lambda_operator<other<assign>, self, typename unwrap_lambda_type<T_arg>::type> >
+ operator = (const T_arg& a) const
+ { typedef lambda_operator<other<assign>, self, typename unwrap_lambda_type<T_arg>::type> lambda_operator_type;
+ return lambda<lambda_operator_type>(lambda_operator_type(this->value_, unwrap_lambda_value(a))); }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+} /* namespace sigc */
+
+_DEPRECATE_IFDEF_END
+
+#endif /* _SIGC_LAMBDA_BASE_HPP_ */
--- /dev/null
+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 <sigc++/adaptors/lambda/select.h>
+
+_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<internal::lambda_select%1> _%1;
+]])
+FOR(1,CALL_SIZE,[[const lambda<internal::lambda_select%1> _%1;
+]])
+} /* namespace sigc */
+
+_DEPRECATE_IFDEF_END
--- /dev/null
+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 <LOOP(class T_arg%1, $2)>
+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 <LOOP(class T_arg%1, $2)>
+ //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 <LOOP(class T_arg%1=void,$2)>
+ 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<internal::lambda_select$1> _$1;
+
+])
+
+divert(0)dnl
+#ifndef _SIGC_LAMBDA_SELECT_HPP_
+#define _SIGC_LAMBDA_SELECT_HPP_
+#include <sigc++/adaptors/lambda/base.h>
+
+_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_ */
--- /dev/null
+# sigc++/adaptors/lambda
+
+# Input: maintainer_mode, python3, handle_built_files, m4_template, m4_include_dir
+# Input and output: built_h_files, built_cc_files, built_h_file_targets,
+# built_cc_file_targets
+
+# .m4 files to build .h and .cc files from.
+adaptors_lambda_cc_m4_files = [
+ 'lambda.cc',
+]
+adaptors_lambda_h_m4_files = [
+ 'base.h',
+ 'select.h',
+]
+foreach file : adaptors_lambda_h_m4_files
+ built_h_files += 'adaptors' / 'lambda' / file
+endforeach
+foreach file : adaptors_lambda_cc_m4_files
+ built_cc_files += 'adaptors' / 'lambda' / file
+endforeach
+
+if maintainer_mode
+ # Maintainer mode. Generate .h and .cc files from .m4 files in macros/ directory.
+ foreach file : adaptors_lambda_cc_m4_files + adaptors_lambda_h_m4_files
+ built_file_target = custom_target('adaptors_lambda_' + file,
+ input: 'macros' / file + '.m4',
+ output: file,
+ command: [
+ python3, handle_built_files, 'build_from_m4',
+ m4_include_dir,
+ '@INPUT@',
+ '@OUTPUT@',
+ ],
+ depend_files: m4_template,
+ build_by_default: maintainer_mode,
+ install: false,
+ )
+ if file.endswith('.cc')
+ built_cc_file_targets += built_file_target
+ else
+ built_h_file_targets += built_file_target
+ endif
+ endforeach
+endif
--- /dev/null
+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() <types> (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<T_functor>::result_type // doesn't compile if T_functor has an overloaded operator()!
+dnl typename functor_trait<T_functor>::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 <LOOP([class T_arg%1], $1)>
+ typename deduce_result_type<LOOP(T_arg%1, $1)>::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 <LOOP([class T_arg%1], $1)>
+ typename deduce_result_type<LOOP(T_arg%1, $1)>::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 <sigc++config.h> //To get SIGC_TEMPLATE_KEYWORD_OPERATOR_OVERLOAD
+#include <sigc++/visit_each.h>
+#include <sigc++/functors/functor_trait.h>
+#include <sigc++/functors/ptr_fun.h>
+#include <sigc++/functors/mem_fun.h>
+#include <sigc++/adaptors/deduce_result_type.h>
+
+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 <class T_functor> 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 <tt>template operator()</tt> member of every argument count
+ * they support. These functions in turn invoke a stored adaptor's
+ * <tt>template operator()</tt>, 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 <class T_functor>
+struct adaptor_functor : public adaptor_base
+{
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+ template <LOOP(class T_arg%1=void, CALL_SIZE)>
+ struct deduce_result_type
+ { typedef sigc::deduce_result_t<LIST(T_functor, LOOP(T_arg%1,CALL_SIZE))> type; };
+#endif
+ typedef typename functor_trait<T_functor>::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 <class T_type>
+ explicit adaptor_functor(const T_type& _A_type)
+ : functor_(_A_type)
+ {}
+
+ /// Functor that is invoked from operator()().
+ mutable T_functor functor_;
+};
+
+template <class T_functor>
+typename adaptor_functor<T_functor>::result_type
+adaptor_functor<T_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 <class T_functor>
+struct visitor<adaptor_functor<T_functor> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const adaptor_functor<T_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 <class T_functor, bool I_isadaptor = std::is_base_of<adaptor_base, T_functor>::value> struct adaptor_trait;
+#else
+template <class T_functor, bool I_isadaptor = std::is_base_of<adaptor_base, T_functor>::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 <class T_functor>
+struct adaptor_trait<T_functor, true>
+{
+ 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<functor_type>.
+ */
+template <class T_functor>
+struct adaptor_trait<T_functor, false>
+{
+ typedef typename functor_trait<T_functor>::result_type result_type;
+ typedef typename functor_trait<T_functor>::functor_type functor_type;
+ typedef adaptor_functor<functor_type> 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 <class T_functor>
+ * struct my_adaptor : public sigc::adapts<T_functor>
+ * {
+ * template <class T_arg1=void, class T_arg2=void>
+ * struct deduce_result_type
+ * { typedef sigc::deduce_result_t<T_functor, T_arg1, T_arg2> type; };
+ * typedef typename sigc::functor_trait<T_functor>::result_type result_type;
+ * //
+ * result_type
+ * operator()() const;
+ * //
+ * template <class T_arg1>
+ * typename deduce_result_type<T_arg1>::type
+ * operator()(T_arg1 _A_arg1) const;
+ * //
+ * template <class T_arg1, class T_arg2>
+ * typename deduce_result_type<T_arg1, T_arg2>::type
+ * operator()(T_arg1 _A_arg1, T_arg2 _A_arg2) const;
+ * //
+ * // Constructs a my_adaptor object that wraps the passed functor.
+ * // Initializes adapts<T_functor>::functor_, which is invoked from operator()().
+ * explicit my_adaptor(const T_functor& _A_functor)
+ * : sigc::adapts<T_functor>(_A_functor) {}
+ * };
+ * } // end namespace my_ns
+ * //
+ * // Specialization of sigc::visitor for my_adaptor.
+ * namespace sigc
+ * {
+ * template <class T_functor>
+ * struct visitor<my_ns::my_adaptor<T_functor> >
+ * {
+ * template <class T_action>
+ * static void do_visit_each(const T_action& _A_action,
+ * const my_ns::my_adaptor<T_functor>& _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 <class T_functor>
+struct adapts : public adaptor_base
+{
+ typedef typename adaptor_trait<T_functor>::result_type result_type;
+ typedef typename adaptor_trait<T_functor>::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 */
--- /dev/null
+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 <LOOP(class T_arg%1, eval(CALL_SIZE))>
+ struct deduce_result_type_internal<LIST($2, LOOP(T_arg%1,eval(CALL_SIZE)))>
+ { typedef typename adaptor_type::template deduce_result_type<LIST(LOOP(_P_(T_arg%1), eval(CALL_SIZE-$2)), LOOP(_P_(typename unwrap_reference<T_type%1>::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 <LOOP([class T_arg%1], eval($2-1))>
+ typename deduce_result_type<LOOP(T_arg%1,eval($2-1))>::type
+ operator()(LOOP(T_arg%1 _A_arg%1,eval($2-1)))
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<LIST(LOOP([_P_(T_arg%1)],eval($1-1)), _P_(typename unwrap_reference<T_bound>::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 <LOOP([class T_arg%1], eval($2-1))>
+ typename deduce_result_type<LOOP(T_arg%1,eval($2-1))>::type
+ sun_forte_workaround(LOOP(T_arg%1 _A_arg%1,eval($2-1)))
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<LIST(LOOP([_P_(T_arg%1)],eval($1-1)), _P_(typename unwrap_reference<T_bound>::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 <LOOP([class T_arg%1], eval($2-1))>
+ typename deduce_result_type<LOOP(T_arg%1,eval($2-1))>::type
+ operator()(LOOP(T_arg%1 _A_arg%1, eval($2-1)))
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<LIST(LOOP([_P_(T_arg%1)],eval($2-1)), LOOP(_P_(typename unwrap_reference<T_type%1>::type), $1))>
+ (LIST(LOOP(_A_arg%1,eval($2-1)), LOOP(bound%1_.invoke(), $1)));
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <LOOP([class T_arg%1], eval($2-1))>
+ typename deduce_result_type<LOOP(T_arg%1,eval($2-1))>::type
+ sun_forte_workaround(LOOP(T_arg%1 _A_arg%1, eval($2-1)))
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<LIST(LOOP([_P_(T_arg%1)],eval($2-1)), LOOP(_P_(typename unwrap_reference<T_type%1>::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 <class T_functor, class T_bound>
+struct bind_functor<$1, T_functor, T_bound, LIST(LOOP(nil, CALL_SIZE - 1))> : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+ifelse($1,0,[#ifndef DOXYGEN_SHOULD_SKIP_THIS
+],)dnl
+ template <LOOP(class T_arg%1=void, eval(CALL_SIZE))>
+ struct deduce_result_type
+ { typedef typename adaptor_type::template deduce_result_type<LIST(LOOP(_P_(T_arg%1),eval($1)), _P_(typename unwrap_reference<T_bound>::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<T_bound>::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<T_functor>(_A_func), bound_(_A_bound)
+ {}
+
+ /// The argument bound to the functor.
+ bound_argument<T_bound> 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 <LIST(class T_functor, LOOP(class T_type%1, $1))>
+struct bind_functor<LIST(-1, T_functor, LIST(LOOP(T_type%1, $1), LOOP(nil, CALL_SIZE - $1)))> : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+ifelse($1,1,[#ifndef DOXYGEN_SHOULD_SKIP_THIS
+],)dnl
+ template <LIST(int count, LOOP(class T_arg%1, eval(CALL_SIZE)))>
+ struct deduce_result_type_internal
+ { typedef typename adaptor_type::template deduce_result_type<LIST(LOOP(_P_(T_arg%1), eval(CALL_SIZE-$1)), LOOP(_P_(typename unwrap_reference<T_type%1>::type), $1))>::type type; };
+FOR(eval($1+1),eval(CALL_SIZE-1),[[DEDUCE_RESULT_TYPE_COUNT($1,%1)]])dnl
+
+ template <LOOP(class T_arg%1=void, eval(CALL_SIZE))>
+ struct deduce_result_type {
+ typedef typename deduce_result_type_internal<internal::count_void<LOOP(T_arg%1, eval(CALL_SIZE))>::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<LOOP(_P_(typename unwrap_reference<T_type%1>::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<T_functor>(_A_func), LOOP(bound%1_(_A_bound%1), $1)
+ {}
+
+ /// The argument bound to the functor.dnl
+FOR(1,$1,[
+ bound_argument<T_type%1> 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 <class T_functor, LOOP(class T_type%1, $1)>
+struct visitor<bind_functor<-1, T_functor, LOOP(T_type%1, $1)> >
+{
+ template <typename T_action>
+ 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 <LIST(LOOP(class T_type%1, $1), class T_functor)>
+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 <sigc++/adaptors/adaptor_trait.h>
+#include <sigc++/adaptors/bound_argument.h>
+
+//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 <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+struct count_void
+ { static const int value=0; };
+template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+struct count_void<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,void>
+ { static const int value=1; };
+template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+struct count_void<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,void,void>
+ { static const int value=2; };
+template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+struct count_void<T_arg1,T_arg2,T_arg3,T_arg4,void,void,void>
+ { static const int value=3; };
+template <class T_arg1,class T_arg2,class T_arg3>
+struct count_void<T_arg1,T_arg2,T_arg3,void,void,void,void>
+ { static const int value=4; };
+template <class T_arg1,class T_arg2>
+struct count_void<T_arg1,T_arg2,void,void,void,void,void>
+ { static const int value=5; };
+template <class T_arg1>
+struct count_void<T_arg1,void,void,void,void,void,void>
+ { static const int value=6; };
+template <>
+struct count_void<void,void,void,void,void,void,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<void> 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() or std::cref() functions.
+ *
+ * @par Example:
+ * @code
+ * int some_int;
+ * sigc::signal<void> 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<void> 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
+ */
+
+/** 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 <LIST(int I_location, class T_functor, LOOP(class T_type%1=nil, CALL_SIZE))>
+#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 <int T_loc, class T_functor, class T_bound>
+struct visitor<bind_functor<T_loc, T_functor, T_bound> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bind_functor<T_loc, T_functor, T_bound>& _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 <int I_location, class T_bound1, class T_functor>
+inline bind_functor<I_location, T_functor, T_bound1>
+bind(const T_functor& _A_func, T_bound1 _A_b1)
+{
+ return bind_functor<I_location, T_functor, T_bound1>
+ (_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
--- /dev/null
+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 <LOOP(class T_arg%1, $1)>
+ inline typename unwrap_reference<T_return>::type operator()(LOOP(T_arg%1 _A_a%1, $1))
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<LOOP(_P_(T_arg%1), $1)>
+ (LOOP(_A_a%1, $1)); return ret_value_.invoke();
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <LOOP(class T_arg%1, $1)>
+ inline typename unwrap_reference<T_return>::type sun_forte_workaround(LOOP(T_arg%1 _A_a%1, $1))
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<LOOP(_P_(T_arg%1), $1)>
+ (LOOP(_A_a%1, $1)); return ret_value_.invoke();
+ }
+ #endif
+
+])
+
+divert(0)dnl
+_FIREWALL([ADAPTORS_BIND_RETURN])
+#include <sigc++/adaptors/adaptor_trait.h>
+#include <sigc++/adaptors/bound_argument.h>
+
+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 <class T_return, class T_functor>
+struct bind_return_functor : public adapts<T_functor>
+{
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+ template <LOOP(class T_arg%1=void, CALL_SIZE)>
+ struct deduce_result_type
+ { typedef typename unwrap_reference<T_return>::type type; };
+#endif
+ typedef typename unwrap_reference<T_return>::type result_type;
+
+ /** Invokes the wrapped functor dropping its return value.
+ * @return The fixed return value.
+ */
+ typename unwrap_reference<T_return>::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<T_functor>(_A_functor), ret_value_(_A_ret_value)
+ {}
+
+ /// The fixed return value.
+ bound_argument<T_return> ret_value_; // public, so that visit_each() can access it
+};
+
+template <class T_return, class T_functor>
+typename unwrap_reference<T_return>::type bind_return_functor<T_return, T_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 <class T_return, class T_functor>
+struct visitor<bind_return_functor<T_return, T_functor> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bind_return_functor<T_return, T_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 <class T_return, class T_functor>
+inline bind_return_functor<T_return, T_functor>
+bind_return(const T_functor& _A_functor, T_return _A_ret_value)
+{ return bind_return_functor<T_return, T_functor>(_A_functor, _A_ret_value); }
+
+} /* namespace sigc */
--- /dev/null
+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 <LOOP(class T_arg%1, $1)>
+ typename deduce_result_type<LOOP(T_arg%1, $1)>::type
+ operator()(LOOP(T_arg%1 _A_a%1, $1))
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<LIST(T_getter, LOOP(T_arg%1,$1))>>
+ (get_(LOOP(_A_a%1, $1)));
+ }
+
+])
+
+define([COMPOSE2_OPERATOR],[dnl
+ template <LOOP(class T_arg%1, $1)>
+ typename deduce_result_type<LOOP(T_arg%1, $1)>::type
+ operator()(LOOP(T_arg%1 _A_a%1, $1))
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<LIST(T_getter1, LOOP(T_arg%1,$1))>,
+ sigc::deduce_result_t<LIST(T_getter2, LOOP(T_arg%1,$1))>>
+ (get1_(LOOP(_A_a%1, $1)), get2_(LOOP(_A_a%1,$1)));
+ }
+
+])
+
+divert(0)
+_FIREWALL([ADAPTORS_COMPOSE])
+#include <sigc++/adaptors/adaptor_trait.h>
+
+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<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 <class T_setter, class T_getter>
+struct compose1_functor : public adapts<T_setter>
+{
+ typedef typename adapts<T_setter>::adaptor_type adaptor_type;
+ typedef T_setter setter_type;
+ typedef T_getter getter_type;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+ template <LOOP(class T_arg%1 = void, CALL_SIZE)>
+ struct deduce_result_type
+ { typedef typename adaptor_type::template deduce_result_type<
+ sigc::deduce_result_t<LIST(T_getter, LOOP(T_arg%1,CALL_SIZE))>
+ >::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<T_setter>(_A_setter), get_(_A_getter)
+ {}
+
+ getter_type get_; // public, so that visit_each() can access it
+};
+
+template <class T_setter, class T_getter>
+typename compose1_functor<T_setter, T_getter>::result_type
+compose1_functor<T_setter, T_getter>::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 <class T_setter, class T_getter1, class T_getter2>
+struct compose2_functor : public adapts<T_setter>
+{
+ typedef typename adapts<T_setter>::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 <LOOP(class T_arg%1=void, CALL_SIZE)>
+ struct deduce_result_type
+ { typedef typename adaptor_type::template deduce_result_type<
+ typename sigc::deduce_result_t<LIST(T_getter1, LOOP(T_arg%1,CALL_SIZE))>,
+ typename sigc::deduce_result_t<LIST(T_getter2, LOOP(T_arg%1,CALL_SIZE))>
+ >::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<T_setter>(_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 <class T_setter, class T_getter1, class T_getter2>
+typename compose2_functor<T_setter, T_getter1, T_getter2>::result_type
+compose2_functor<T_setter, T_getter1, T_getter2>::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 <class T_setter, class T_getter>
+struct visitor<compose1_functor<T_setter, T_getter> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const compose1_functor<T_setter, T_getter>& _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 <class T_setter, class T_getter1, class T_getter2>
+struct visitor<compose2_functor<T_setter, T_getter1, T_getter2> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const compose2_functor<T_setter, T_getter1, T_getter2>& _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 <class T_setter, class T_getter>
+inline compose1_functor<T_setter, T_getter>
+compose(const T_setter& _A_setter, const T_getter& _A_getter)
+ { return compose1_functor<T_setter, T_getter>(_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 <class T_setter, class T_getter1, class T_getter2>
+inline compose2_functor<T_setter, T_getter1, T_getter2>
+compose(const T_setter& _A_setter, const T_getter1& _A_getter1, const T_getter2& _A_getter2)
+ { return compose2_functor<T_setter, T_getter1, T_getter2>(_A_setter, _A_getter1, _A_getter2); }
+
+} /* namespace sigc */
--- /dev/null
+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 <sigc++/functors/functor_trait.h>
+
+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.
+ * <tt>typename deduce_result_type<functor_type, [list of arg_types]>::type</tt>
+ * 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
+ * <tt>typename deduce_result_type<functor_type, [list of arg_types]>::type</tt>
+ * to determine the return type of their <tt>templated operator()</tt> 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
+ * <tt>template operator()</tt> overload.
+ *
+ * @ingroup adaptors
+ */
+template<class T_functor, class... T_args>
+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<class U_functor, typename = typename std::is_base_of<adaptor_base, T_functor>::type>
+ static
+ typename U_functor::template deduce_result_type<T_args...>::type
+ test();
+
+ //Otherwise, the compiler will choose this fallback method.
+ template<class U_functor>
+ static
+ typename functor_trait<T_functor>::result_type
+ test();
+
+ using type = decltype (test<T_functor> ());
+};
+
+template<typename T_functor, typename... T_args>
+using deduce_result_t = typename deduce_result_type<T_functor, T_args...>::type;
+
+dnl #ifdef SIGC_CXX_TYPEOF
+dnl FOR(0,CALL_SIZE,[[DEDUCE_RESULT_TYPE_TYPEOF(%1,CALL_SIZE)]])
+dnl #endif
+dnl
+} /* namespace sigc */
--- /dev/null
+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 <LOOP(class T_arg%1, $1)>
+ typename deduce_result_type<LOOP(T_arg%1,$1)>::type
+ operator()(LOOP(T_arg%1 _A_a%1, $1))
+ {
+ try
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<LOOP(_P_(T_arg%1), $1)>
+ (LOOP(_A_a%1, $1));
+ }
+ catch (...)
+ { return catcher_(); }
+ }
+
+])
+
+divert(0)dnl
+_FIREWALL([ADAPTORS_EXCEPTION_CATCH])
+#include <sigc++/adaptors/adaptor_trait.h>
+
+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<int> some_signal;
+ * some_signal.connect(sigc::exception_catch(&foo, my_catch));
+ * @endcode
+ *
+ * @ingroup adaptors
+ */
+
+template <class T_functor, class T_catcher, class T_return = typename adapts<T_functor>::result_type>
+struct exception_catch_functor : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+ template <LOOP(class T_arg%1=void, CALL_SIZE)>
+ struct deduce_result_type
+ { typedef typename adaptor_type::template deduce_result_type<LOOP(_P_(T_arg%1),CALL_SIZE)>::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<T_functor>(_A_func), catcher_(_A_catcher)
+ {}
+
+ T_catcher catcher_;
+};
+
+template <class T_functor, class T_catcher, class T_return>
+typename exception_catch_functor<T_functor, T_catcher, T_return>::result_type
+exception_catch_functor<T_functor, T_catcher, T_return>::operator()()
+ {
+ try
+ { return this->functor_(); }
+ catch (...)
+ { return catcher_(); }
+ }
+
+// void specialization
+template <class T_functor, class T_catcher>
+struct exception_catch_functor<T_functor, T_catcher, void> : public adapts<T_functor>
+{
+ typedef void result_type;
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+ template <LOOP(class T_arg%1=void, CALL_SIZE)>
+ struct deduce_result_type
+ { typedef typename adaptor_type::template deduce_result_type<LOOP(_P_(T_arg%1),CALL_SIZE)>::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<T_functor>(_A_func), catcher_(_A_catcher)
+ {}
+ ~exception_catch_functor() {}
+
+ T_catcher catcher_;
+};
+
+template <class T_functor, class T_catcher>
+void exception_catch_functor<T_functor, T_catcher, void>::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 <class T_functor, class T_catcher, class T_return>
+struct visitor<exception_catch_functor<T_functor, T_catcher, T_return> >
+{
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const exception_catch_functor<T_functor, T_catcher, T_return>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.functor_);
+ sigc::visit_each(_A_action, _A_target.catcher_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+template <class T_functor, class T_catcher>
+inline exception_catch_functor<T_functor, T_catcher>
+exception_catch(const T_functor& _A_func, const T_catcher& _A_catcher)
+ { return exception_catch_functor<T_functor, T_catcher>(_A_func, _A_catcher); }
+
+} /* namespace sigc */
--- /dev/null
+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 <LOOP(class T_arg%1=void, CALL_SIZE)>
+ struct deduce_result_type
+ifelse($1,0,[dnl
+ { typedef typename adaptor_type::template deduce_result_type<LOOP(_P_(T_arg%1),eval($2-1))>::type type; };
+],[dnl
+ { typedef typename adaptor_type::template deduce_result_type<LIST(LOOP(_P_(T_arg%1),eval($1-1)), FOR(eval($1+1),$2,[_P_(T_arg%1),]))>::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 <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ operator()(T_arg1)
+ { return this->functor_(); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::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 <LOOP([class T_arg%1], $2)>
+ typename deduce_result_type<LOOP(T_arg%1, $2)>::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),[_P_(T_arg%1),]))>
+ (LIST(FOR(1,eval($2-1),[_A_a%1,]))); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <LOOP([class T_arg%1], $2)>
+ typename deduce_result_type<LOOP(T_arg%1, $2)>::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),[_P_(T_arg%1),]))>
+ (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 <LOOP([class T_arg%1], $2)>
+ typename deduce_result_type<LOOP(T_arg%1, $2)>::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),[_P_(T_arg%1),]),FOR(eval($1+1), $2,[_P_(T_arg%1),]))>
+ (LIST(FOR(1,eval($1-1),[_A_a%1,]),FOR(eval($1+1),$2,[_A_a%1,]))); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <LOOP([class T_arg%1], $2)>
+ typename deduce_result_type<LOOP(T_arg%1, $2)>::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),[_P_(T_arg%1),]),FOR(eval($1+1), $2,[_P_(T_arg%1),]))>
+ (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 <class T_functor>
+struct hide_functor <$1, T_functor> : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::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<T_functor>(_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 <sigc++/adaptors/adaptor_trait.h>
+
+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<void,int> 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 <int I_location, class T_functor>
+#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 <int I_location, class T_functor>
+struct visitor<hide_functor<I_location, T_functor> >
+{
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const hide_functor<I_location, T_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 <int I_location, class T_functor>
+inline hide_functor<I_location, T_functor>
+hide(const T_functor& _A_func)
+ { return hide_functor<I_location, T_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 <class T_functor>
+inline hide_functor<-1, T_functor>
+hide(const T_functor& _A_func)
+ { return hide_functor<-1, T_functor> (_A_func); }
+
+} /* namespace sigc */
--- /dev/null
+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 <LOOP(class T_arg%1, $1)>
+ typename deduce_result_type<LOOP(T_arg%1,$1)>::type
+ operator()(LOOP(T_arg%1 _A_a%1, $1))
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<LOOP(type_trait_take_t<T_type%1>, $1)>
+ (LOOP([[static_cast<T_type%1>(_A_a%1)]], $1));
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <LOOP(class T_arg%1, $1)>
+ typename deduce_result_type<LOOP(T_arg%1,$1)>::type
+ sun_forte_workaround(LOOP(T_arg%1 _A_a%1, $1))
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<LOOP(type_trait_take_t<T_type%1>, $1)>
+ (LOOP([[static_cast<T_type%1>(_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 <LIST(LOOP(class T_arg%1, $1), class T_return)>
+inline retype_functor<LIST(pointer_functor$1<LIST(LOOP(T_arg%1, $1), T_return)>, LOOP(T_arg%1, $1)) >
+retype(const pointer_functor$1<LIST(LOOP(T_arg%1, $1), T_return)>& _A_functor)
+{ return retype_functor<LIST(pointer_functor$1<LIST(LOOP(T_arg%1, $1), T_return)>, 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 <LIST(class T_return, class T_obj, LOOP(class T_arg%1, $1))>
+inline retype_functor<LIST($2[]mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $1))>, LOOP(T_arg%1, $1)) >
+retype(const $2[]mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $1))>& _A_functor)
+{ return retype_functor<LIST($2[]mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $1))>, LOOP(T_arg%1, $1)) >
+ (_A_functor); }
+
+])
+
+divert(0)dnl
+_FIREWALL([ADAPTORS_RETYPE])
+#include <sigc++/adaptors/adaptor_trait.h>
+#include <sigc++/functors/ptr_fun.h>
+#include <sigc++/functors/mem_fun.h>
+#include <sigc++/functors/slot.h>
+
+//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<void,float> 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<int>(&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 <LIST(class T_functor, LOOP(class T_type%1=nil, CALL_SIZE))>
+struct retype_functor
+ : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+ template <LOOP(class T_arg%1=void, CALL_SIZE)>
+ struct deduce_result_type
+ { typedef typename adaptor_type::template deduce_result_type<LOOP(_P_(T_arg%1),CALL_SIZE)>::type type; };
+#endif
+ typedef typename adapts<T_functor>::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<T_functor> _A_functor)
+ : adapts<T_functor>(_A_functor)
+ {}
+};
+
+template <LIST(class T_functor, LOOP(class T_type%1, CALL_SIZE))>
+typename retype_functor<LIST(T_functor, LOOP(T_type%1, CALL_SIZE))>::result_type
+retype_functor<LIST(T_functor, LOOP(T_type%1, CALL_SIZE))>::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 <LIST(class T_functor, LOOP(class T_type%1, CALL_SIZE))>
+struct visitor<retype_functor<LIST(T_functor, LOOP(T_type%1, CALL_SIZE))> >
+{
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const retype_functor<LIST(T_functor, LOOP(T_type%1, CALL_SIZE))>& _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 <LIST(class T_return, LOOP(class T_arg%1, CALL_SIZE))>
+inline retype_functor<LIST(slot<LIST(T_return, LOOP(T_arg%1, CALL_SIZE))>, LOOP(T_arg%1, CALL_SIZE)) >
+retype(const slot<LIST(T_return, LOOP(T_arg%1, CALL_SIZE))>& _A_functor)
+{ return retype_functor<LIST(slot<LIST(T_return, LOOP(T_arg%1, CALL_SIZE))>, 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
--- /dev/null
+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 <LOOP(class T_arg%1, $1)>
+ inline T_return operator()(LOOP(T_arg%1 _A_a%1, $1))
+ { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<LOOP(_P_(T_arg%1), $1)>
+ (LOOP(_A_a%1, $1)));
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <LOOP(class T_arg%1, $1)>
+ inline T_return sun_forte_workaround(LOOP(T_arg%1 _A_a%1, $1))
+ { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<LOOP(_P_(T_arg%1), $1)>
+ (LOOP(_A_a%1, $1)));
+ }
+ #endif
+
+])
+define([RETYPE_RETURN_VOID_OPERATOR],[dnl
+ template <LOOP(class T_arg%1, $1)>
+ inline void operator()(LOOP(T_arg%1 _A_a%1, $1))
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<LOOP(_P_(T_arg%1), $1)>
+ (LOOP(_A_a%1, $1));
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <LOOP(class T_arg%1, $1)>
+ inline void sun_forte_workaround(LOOP(T_arg%1 _A_a%1, $1))
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<LOOP(_P_(T_arg%1), $1)>
+ (LOOP(_A_a%1, $1));
+ }
+ #endif
+
+])
+
+divert(0)dnl
+_FIREWALL([ADAPTORS_RETYPE_RETURN])
+#include <sigc++/adaptors/adaptor_trait.h>
+
+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 <class T_return, class T_functor>
+struct retype_return_functor : public adapts<T_functor>
+{
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+ template <LOOP(class T_arg%1=void, CALL_SIZE)>
+ 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<T_functor>(_A_functor)
+ {}
+};
+
+template <class T_return, class T_functor>
+T_return retype_return_functor<T_return, T_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<void>.
+ *
+ * @ingroup retype
+ */
+/* The void specialization is needed because of explicit cast to T_return.
+ */
+template <class T_functor>
+struct retype_return_functor<void, T_functor> : public adapts<T_functor>
+{
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+ template <LOOP(class T_arg%1=void, CALL_SIZE)>
+ 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<T_functor>(_A_functor)
+ {}
+};
+
+template <class T_functor>
+void retype_return_functor<void, T_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 <class T_return, class T_functor>
+struct visitor<retype_return_functor<T_return, T_functor> >
+{
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const retype_return_functor<T_return, T_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 <class T_return, class T_functor>
+inline retype_return_functor<T_return, T_functor>
+retype_return(const T_functor& _A_functor)
+ { return retype_return_functor<T_return, T_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 <class T_functor>
+inline retype_return_functor<void, T_functor>
+hide_return(const T_functor& _A_functor)
+ { return retype_return_functor<void, T_functor>(_A_functor); }
+
+} /* namespace sigc */
--- /dev/null
+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 <http://www.gnu.org/licenses/>.
+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 <LOOP([typename T_arg%1], $1)>
+ typename deduce_result_type<LOOP(T_arg%1, $1)>::type
+ operator()(LOOP(T_arg%1 _A_arg%1, $1))
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<LOOP([
+ _P_(T_arg%1)], $1)>
+ (LOOP(_A_arg%1, $1));
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <LOOP([typename T_arg%1], $1)>
+ typename deduce_result_type<LOOP(T_arg%1, $1)>::type
+ sun_forte_workaround(LOOP(T_arg%1 _A_arg%1, $1))
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<LOOP([
+ _P_(T_arg%1)], $1)>
+ (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 <typename T_functor, LOOP(typename T_obj%1, $1)>
+class track_obj_functor$1 : public track_obj_functor1<T_functor, T_obj1>
+{
+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<T_functor, T_obj1>(_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<T_obj%1> 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 <typename T_functor, LOOP(typename T_obj%1, $1)>
+struct visitor<track_obj_functor$1<T_functor, LOOP(T_obj%1, $1)> >
+{
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const track_obj_functor$1<T_functor, LOOP(T_obj%1, $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 <typename T_functor, LOOP(typename T_obj%1, $1)>
+inline track_obj_functor$1<T_functor, LOOP(T_obj%1, $1)>
+track_obj(const T_functor& _A_func, LOOP(const T_obj%1& _A_obj%1, $1))
+{
+ return track_obj_functor$1<T_functor, LOOP(T_obj%1, $1)>
+ (_A_func, LOOP(_A_obj%1, $1));
+}
+
+])dnl end TRACK_OBJECT
+
+divert(0)dnl
+_FIREWALL([ADAPTORS_TRACK_OBJ])
+#include <sigc++/adaptors/adaptor_trait.h>
+#include <sigc++/limit_reference.h>
+
+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<void> 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 <typename T_functor, typename T_obj1>
+class track_obj_functor1 : public adapts<T_functor>
+{
+public:
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+ template <LOOP(typename T_arg%1=void, CALL_SIZE)>
+ struct deduce_result_type
+ { typedef typename adaptor_type::template deduce_result_type<LOOP(_P_(T_arg%1), CALL_SIZE)>::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<T_functor>(_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<T_obj1> 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 */
--- /dev/null
+# sigc++/adaptors
+
+# Input: maintainer_mode, python3, handle_built_files, m4_template, m4_include_dir
+# Input and output: built_h_files, built_h_file_targets
+
+# .m4 files to build .h files from.
+adaptors_h_m4_files = [
+ 'adaptor_trait.h',
+ 'bind.h',
+ 'bind_return.h',
+ 'compose.h',
+ 'deduce_result_type.h',
+ 'exception_catch.h',
+ 'hide.h',
+ 'retype.h',
+ 'retype_return.h',
+ 'track_obj.h',
+]
+foreach file : adaptors_h_m4_files
+ built_h_files += 'adaptors' / file
+endforeach
+
+if maintainer_mode
+ # Maintainer mode. Generate .h files from .m4 files in macros/ directory.
+ foreach file : adaptors_h_m4_files
+ built_h_file_targets += custom_target('adaptors_' + file,
+ input: 'macros' / file + '.m4',
+ output: file,
+ command: [
+ python3, handle_built_files, 'build_from_m4',
+ m4_include_dir,
+ '@INPUT@',
+ '@OUTPUT@',
+ ],
+ depend_files: m4_template,
+ build_by_default: maintainer_mode,
+ install: false,
+ )
+ endforeach
+endif
--- /dev/null
+/*
+ * 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
+ *
+ */
+#ifndef _SIGC_BIND_HPP_
+#define _SIGC_BIND_HPP_
+
+#include <sigc++/adaptors/bind.h>
+
+#endif /* _SIGC_BIND_HPP_ */
--- /dev/null
+/*
+ * 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
+ *
+ */
+#ifndef _SIGC_BIND_RETURN_HPP_
+#define _SIGC_BIND_RETURN_HPP_
+
+#include <sigc++/adaptors/bind_return.h>
+
+
+#endif /* _SIGC_BIND_RETURN_HPP_ */
--- /dev/null
+/*
+ * 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 <sigc++/connection.h>
+
+namespace sigc {
+
+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& 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::operator=(const connection& c)
+{
+ set_slot(c.slot_);
+ return *this;
+}
+
+connection::~connection()
+{
+ if (slot_)
+ slot_->remove_destroy_notify_callback(this);
+}
+
+bool connection::empty() const noexcept
+{
+ return (!slot_ || slot_->empty());
+}
+
+bool connection::connected() const noexcept
+{
+ return !empty();
+}
+
+bool connection::blocked() const noexcept
+{
+ return (slot_ ? slot_->blocked() : false);
+}
+
+bool connection::block(bool should_block) noexcept
+{
+ return (slot_ ? slot_->block(should_block) : false);
+}
+
+bool connection::unblock() noexcept
+{
+ return (slot_ ? slot_->unblock() : false);
+}
+
+void connection::disconnect()
+{
+ if (slot_)
+ slot_->disconnect(); // This notifies slot_'s parent.
+}
+
+connection::operator bool() 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)
+{
+ auto self = reinterpret_cast<connection*>(data);
+ self->slot_ = nullptr;
+ return nullptr;
+}
+
+} /* namespace sigc */
--- /dev/null
+/*
+ * 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
+ *
+ */
+#ifndef _SIGC_CONNECTION_HPP_
+#define _SIGC_CONNECTION_HPP_
+#include <sigc++config.h>
+#include <sigc++/signal.h>
+
+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
+ * 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()).
+ *
+ * @ingroup signal
+ */
+struct SIGC_API connection
+{
+ /** Constructs an empty connection object. */
+ connection() noexcept;
+
+ /** Constructs a connection object copying an existing one.
+ * @param c The connection object to make a copy from.
+ */
+ 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 <typename T_slot>
+ connection(const slot_iterator<T_slot>& 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.
+ */
+ explicit connection(slot_base& sl);
+
+ /** 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.
+ */
+ template <typename T_slot>
+ connection& operator=(const slot_iterator<T_slot>& it)
+ { set_slot(&(*it)); return *this; }
+
+ ~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.
+ 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);
+
+private:
+ void set_slot(slot_base* sl);
+
+ /* Referred slot. Set to zero from notify().
+ * A value of zero indicates an "empty" connection.
+ */
+ slot_base* slot_;
+};
+
+} /* namespace sigc */
+
+
+#endif /* _SIGC_TRACKABLE_HPP_ */
--- /dev/null
+## Copyright (c) 2009 Openismus GmbH <http://www.openismus.com/>
+##
+## This file is part of libsigc++.
+##
+## libsigc++ 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.
+##
+## libsigc++ 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 <http://www.gnu.org/licenses/>.
+
+# 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 \
+ reference_wrapper.h \
+ retype_return.h \
+ signal_base.h \
+ slot.h \
+ trackable.h \
+ type_traits.h \
+ visit_each.h \
+ adaptors/adaptors.h \
+ adaptors/bound_argument.h \
+ functors/functors.h \
+ functors/slot_base.h
+
+sigc_sources_cc = \
+ signal_base.cc \
+ trackable.cc \
+ connection.cc \
+ functors/slot_base.cc \
+ adaptors/lambda/lambda.cc
--- /dev/null
+// -*- 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
+ *
+ */
+#ifndef _SIGC_FUNCTOR_HPP_
+#define _SIGC_FUNCTOR_HPP_
+
+#include <sigc++/functors/slot.h>
+#include <sigc++/functors/ptr_fun.h>
+#include <sigc++/functors/mem_fun.h>
+
+#endif /* _SIGC_FUNCTOR_HPP_ */
--- /dev/null
+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 <LIST(LOOP(class T_arg%1, $1), class T_return)> class pointer_functor$1;
+template <LIST(LOOP(class T_arg%1, $1), class T_return)>
+struct functor_trait<T_return (*)(LOOP(T_arg%1, $1)), false, false>
+{
+ typedef T_return result_type;
+ typedef pointer_functor$1<LIST(LOOP(T_arg%1, $1), T_return)> functor_type;
+};
+
+])
+define([FUNCTOR_MEM_FUN],[dnl
+template <LIST(class T_return, class T_obj, LOOP(class T_arg%1, $1))> class mem_functor$1;
+template <LIST(class T_return, class T_obj, LOOP(class T_arg%1, $1))> class const_mem_functor$1;
+template <LIST(LOOP(class T_arg%1, $1), class T_return, class T_obj)>
+struct functor_trait<T_return (T_obj::*)(LOOP(T_arg%1, $1)), false, false>
+{
+ typedef T_return result_type;
+ typedef mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $1))> functor_type;
+};
+template <LIST(LOOP(class T_arg%1, $1), class T_return, class T_obj)>
+struct functor_trait<T_return (T_obj::*)(LOOP(T_arg%1, $1)) const, false, false>
+{
+ typedef T_return result_type;
+ typedef const_mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $1))> functor_type;
+};
+
+])
+
+divert(0)dnl
+_FIREWALL([FUNCTORS_FUNCTOR_TRAIT])
+#include <sigc++/type_traits.h>
+#include <type_traits>
+
+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
+ * <tt>typedef T_return result_type;</tt> 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 <typename T_functor>
+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 <typename X_functor>
+ 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<T_functor*>(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 <class T_functor,
+ bool I_derives_functor_base = std::is_base_of<functor_base,T_functor>::value,
+ bool I_can_use_decltype = can_deduce_result_type_with_decltype<T_functor>::value>
+struct functor_trait
+{
+ typedef void result_type;
+ typedef T_functor functor_type;
+};
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+template <class T_functor, bool I_can_use_decltype>
+struct functor_trait<T_functor, true, I_can_use_decltype>
+{
+ typedef typename T_functor::result_type result_type;
+ typedef T_functor functor_type;
+};
+
+template <typename T_functor>
+struct functor_trait<T_functor, false, true>
+{
+ typedef typename functor_trait<decltype(&T_functor::operator()), false, false>::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 <class T_functor> \
+struct functor_trait<T_functor, false, false> \
+{ \
+ 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<T_functor, false, false> \
+{ \
+ typedef T_return result_type; \
+ typedef T_functor functor_type; \
+}; \
+template <> \
+struct functor_trait<T_functor, false, true> \
+{ \
+ 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 <tt>decltype</tt>, 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 */
--- /dev/null
+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 <LIST(class T_return, class T_obj, LOOP(class T_arg%1, $1))>
+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) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @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<T_arg%1> _A_a%1, $1))) const
+ { return (_A_obj->*(this->func_ptr_))(LOOP(_A_a%1, $1)); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** 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<T_arg%1> _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 <LIST(class T_return, class T_obj, LOOP(class T_arg%1, $1))>
+class bound_[$2]mem_functor$1
+ : public [$2]mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $1))>
+{
+ typedef [$2]mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $1))> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_[$2]mem_functor$1 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @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)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** 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<T_arg%1> _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<T_obj> 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 <LIST(class T_return, class T_obj, LOOP(class T_arg%1, $1))>
+struct visitor<bound_[$2]mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $1))> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_[$2]mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $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 <LIST(LOOP(class T_arg%1, $1), class T_return, class T_obj)>
+inline [$3]mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $1))>
+mem_fun[]ifelse($2,, $1)(T_return (T_obj::*_A_func)(LOOP(T_arg%1,$1)) $5)
+{ return [$3]mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $1))>(_A_func); }
+
+])
+define([BOUND_MEM_FUN],[dnl
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_[$3]mem_functor$1 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <LIST(LOOP(class T_arg%1, $1), class T_return, class T_obj, class T_obj2)>
+inline bound_[$3]mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $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<LIST(T_return, T_obj, LOOP(T_arg%1, $1))>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** 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 <LIST(LOOP(class T_arg%1, $1), class T_return, class T_obj, class T_obj2)>
+inline bound_[$3]mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $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<LIST(T_return, T_obj, LOOP(T_arg%1, $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 <sigc++/type_traits.h>
+#include <sigc++/functors/functor_trait.h>
+#include <sigc++/limit_reference.h>
+
+namespace sigc {
+
+/** @defgroup mem_fun mem_fun()
+ * mem_fun() Creates a functor from a pointer to a method.
+ *
+ * Optionally, a reference or pointer 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 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.
+ *
+ * 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<void, int> 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<void, int> 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<void, int> sl = sigc::mem_fun1<int>(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 */
--- /dev/null
+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 <LIST(LOOP(class T_arg%1, $1), class T_return)>
+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<T_arg%1> _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 <LIST(LOOP(class T_arg%1, $1), class T_return)>
+inline pointer_functor$1<LIST(LOOP(T_arg%1, $1), T_return)>
+ptr_fun[]ifelse($2,, $1)(T_return (*_A_func)(LOOP(T_arg%1,$1)))
+{ return pointer_functor$1<LIST(LOOP(T_arg%1, $1), T_return)>(_A_func); }
+
+])
+
+divert(0)
+_FIREWALL([FUNCTORS_PTR_FUN])
+#include <sigc++/type_traits.h>
+#include <sigc++/functors/functor_trait.h>
+
+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<void, int> 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<void, long> sl = sigc::ptr_fun1<int>(&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<void, int> 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 */
--- /dev/null
+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 <LIST(class T_return, LOOP(class T_arg%1, $1))>
+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 (sigc::internal::function_pointer_cast<call_type>(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 <class T_functor>
+ slot$1(const T_functor& _A_func)
+ : slot_base(new internal::typed_slot_rep<T_functor>(_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<LIST(T_functor, T_return, LOOP(T_arg%1, $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 <LIST(typename T_return, LOOP(typename T_arg%1, $1))>
+struct visitor<slot$1<LIST(T_return, LOOP(T_arg%1, $1))>>
+{
+ static void do_visit_each(const internal::limit_derived_target<trackable*, internal::slot_do_bind>& _A_action,
+ const slot$1<LIST(T_return, LOOP(T_arg%1, $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<trackable*, internal::slot_do_unbind>& _A_action,
+ const slot$1<LIST(T_return, LOOP(T_arg%1, $1))>& _A_target)
+ {
+ if (_A_target.rep_ && _A_target.rep_->parent_ == _A_action.action_.rep_)
+ _A_target.rep_->set_parent(nullptr, nullptr);
+ }
+
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const slot$1<LIST(T_return, LOOP(T_arg%1, $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<void, int> 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 an unnecessary extra wrapper.
+ *
+ * @deprecated Please use the syntax similar to that used by std::function<>:
+ * @code
+ * sigc::slot<void(bool, int)> some_slot;
+ * @endcode
+ *
+ * @ingroup slot
+ */
+template <LIST(class T_return, LOOP(class T_arg%1 = nil, $1))>
+class slot],[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.
+ *
+ * @deprecated Please use the syntax similar to that used by std::function<>:
+ * @code
+ * sigc::slot<void(bool, int)> some_slot;
+ * @endcode
+ *
+dnl *
+dnl * @ingroup slot
+ */
+template <LIST(class T_return, LOOP(class T_arg%1, $1))>
+class slot <LIST(T_return, LIST(LOOP(T_arg%1, $1), LOOP(nil, CALL_SIZE - $1)))>])
+ : public slot$1<LIST(T_return, LOOP(T_arg%1, $1))>
+{
+public:
+ typedef slot$1<LIST(T_return, LOOP(T_arg%1, $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 <class T_functor>
+ 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<const parent_type&>(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<parent_type&>(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 <LIST(typename T_return, LOOP(typename T_arg%1, $1))>
+struct visitor<slot<LIST(T_return, LOOP(T_arg%1, $1))>>
+{
+ static void do_visit_each(const internal::limit_derived_target<trackable*, internal::slot_do_bind>& _A_action,
+ const slot<LIST(T_return, LOOP(T_arg%1, $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<trackable*, internal::slot_do_unbind>& _A_action,
+ const slot<LIST(T_return, LOOP(T_arg%1, $1))>& _A_target)
+ {
+ if (_A_target.rep_ && _A_target.rep_->parent_ == _A_action.action_.rep_)
+ _A_target.rep_->set_parent(nullptr, nullptr);
+ }
+
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const slot<LIST(T_return, LOOP(T_arg%1, $1))>& _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<LIST(class T_functor, class T_return, LOOP(class T_arg%1, $1))>
+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<T_functor> typed_slot;
+ typed_slot *typed_rep = static_cast<typed_slot*>(rep);dnl
+ifelse($1,0,[
+ return (typed_rep->functor_)();
+],[
+ return (typed_rep->functor_).SIGC_WORKAROUND_OPERATOR_PARENTHESES<LOOP([_R_(T_arg%1)],$1)>
+ (LOOP(a_%1, $1));
+])dnl
+ }
+
+ /** Forms a function pointer from call_it().
+ * @return A function pointer formed from call_it().
+ */
+ static hook address()
+ { return sigc::internal::function_pointer_cast<hook>(&call_it); }
+};
+
+])
+
+divert(0)dnl
+_FIREWALL([FUNCTORS_SLOT])
+#include <sigc++/trackable.h>
+#include <sigc++/visit_each.h>
+#include <sigc++/adaptors/adaptor_trait.h>
+#include <sigc++/functors/slot_base.h>
+
+//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 {
+
+// 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 <typename T_out, typename T_in>
+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<T_out>(reinterpret_cast<void (*)()>(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 <class T_functor>
+struct typed_slot_rep : public slot_rep
+{
+ typedef typed_slot_rep<T_functor> 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<T_functor>::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<trackable*>(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<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;
+
+ inline ~typed_slot_rep()
+ {
+ call_ = nullptr;
+ destroy_ = nullptr;
+ sigc::visit_each_type<trackable*>(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<self*>(reinterpret_cast<slot_rep*>(data));
+ self_->call_ = nullptr;
+ self_->destroy_ = nullptr;
+ sigc::visit_each_type<trackable*>(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<slot_rep*>(data);
+ return static_cast<slot_rep*>(new self(*static_cast<self*>(a_rep)));
+ }
+};
+
+FOR(0,CALL_SIZE,[[SLOT_CALL(%1)]])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().
+ * - @e T_arg Argument types used in the definition of call_it().
+ *
+ */
+template<class T_functor, class T_return, class... T_arg>
+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_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<T_arg>... a_)
+ {
+ using typed_slot = typed_slot_rep<T_functor>;
+ typed_slot *typed_rep = static_cast<typed_slot*>(rep);
+ return (typed_rep->functor_).SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_arg>...>
+ (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<hook>(&call_it); }
+};
+
+/** Abstracts functor execution.
+ * call_it() invokes a functor without parameters of type @e T_functor.
+ * address() forms a function pointer from call_it().
+ *
+ * This is a specialization for functors without parameters.
+ *
+ * The following template arguments are used:
+ * - @e T_functor The functor type.
+ * - @e T_return The return type of call_it().
+ *
+ */
+template<class T_functor, class T_return>
+struct slot_call<T_functor, T_return>
+{
+ /** Invokes a functor of type @p T_functor.
+ * @param rep slot_rep object that holds a functor of type @p T_functor.
+ * @return The return values of the functor invocation.
+ */
+ static T_return call_it(slot_rep* rep)
+ {
+ using typed_slot = typed_slot_rep<T_functor>;
+ typed_slot *typed_rep = static_cast<typed_slot*>(rep);
+ return (typed_rep->functor_)();
+ }
+
+ /** Forms a function pointer from call_it().
+ * @return A function pointer formed from call_it().
+ */
+ static hook address()
+ { return sigc::internal::function_pointer_cast<hook>(&call_it); }
+};
+
+} /* 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)]])
+
+/** 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<void(bool, int)> some_slot;
+ * @endcode
+ *
+ * Alternatively, you may use this syntax:
+ * @code
+ * sigc::slot<void, bool, int> 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
+ */
+template <class T_return, class... T_arg>
+class slot<T_return(T_arg...)>
+ : public slot_base
+{
+public:
+ using result_type = T_return;
+ //TODO: using arg_type_ = type_trait_take_t<T_arg>;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+private:
+ using rep_type = internal::slot_rep;
+public:
+ using call_type = T_return (*)(rep_type*, type_trait_take_t<T_arg>...);
+#endif
+
+ /** Invoke the contained functor unless slot is in blocking state.
+ * @param _A_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<T_arg>... _A_a) const
+ {
+ if (!empty() && !blocked())
+ return (sigc::internal::function_pointer_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a...);
+ return T_return();
+ }
+
+ inline slot() {}
+
+ /** Constructs a slot from an arbitrary functor.
+ * @param _A_func The desired functor the new slot should be assigned to.
+ */
+ template <class T_functor>
+ slot(const T_functor& _A_func)
+ : slot_base(new internal::typed_slot_rep<T_functor>(_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<T_functor, T_return, T_arg...>::address();
+ }
+
+ /** Constructs a slot, copying an existing one.
+ * @param src The existing slot to copy.
+ */
+ slot(const slot& 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(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)
+ {
+ 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& operator=(slot&& src)
+ {
+ slot_base::operator=(std::move(src));
+ return *this;
+ }
+};
+
+} /* namespace sigc */
+
+#ifdef SIGC_NIL_HAS_BEEN_PUSHED
+ #undef SIGC_NIL_HAS_BEEN_PUSHED
+ #pragma pop_macro("nil")
+#endif
--- /dev/null
+# sigc++/functors
+
+# Input: maintainer_mode, python3, handle_built_files, m4_template, m4_include_dir
+# Input and output: built_h_files, built_h_file_targets
+
+# .m4 files to build .h files from.
+functors_h_m4_files = [
+ 'functor_trait.h',
+ 'mem_fun.h',
+ 'ptr_fun.h',
+ 'slot.h',
+]
+foreach file : functors_h_m4_files
+ built_h_files += 'functors' / file
+endforeach
+
+if maintainer_mode
+ # Maintainer mode. Generate .h files from .m4 files in macros/ directory.
+ foreach file : functors_h_m4_files
+ built_h_file_targets += custom_target('functors_' + file,
+ input: 'macros' / file + '.m4',
+ output: file,
+ command: [
+ python3, handle_built_files, 'build_from_m4',
+ m4_include_dir,
+ '@INPUT@',
+ '@OUTPUT@',
+ ],
+ depend_files: m4_template,
+ build_by_default: maintainer_mode,
+ install: false,
+ )
+ endforeach
+endif
--- /dev/null
+/*
+ * Copyright 2003, 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 <sigc++/functors/slot_base.h>
+
+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
+{
+ destroy_notify_struct() noexcept : deleted_(false) { }
+
+ static void* notify(void* data) noexcept
+ {
+ auto self_ = reinterpret_cast<destroy_notify_struct*>(data);
+ self_->deleted_ = true;
+ return nullptr;
+ }
+
+ bool deleted_;
+};
+
+// 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
+{
+public:
+ dummy_slot_rep() : slot_rep(nullptr, nullptr, &clone) {}
+ static void* clone(void*) { return new dummy_slot_rep(); }
+};
+} // anonymous namespace
+
+namespace sigc
+{
+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_)
+{
+ return malloc(size_);
+}
+
+void slot_rep::operator delete(void* p)
+{
+ free(p);
+}
+#endif
+
+void slot_rep::disconnect()
+{
+ // Invalidate the slot.
+ // _Must_ be done here because parent_ might defer the actual
+ // destruction of the slot_rep and try to invoke it before that point.
+ // Must be done also for a slot without a parent, according to
+ // https://bugzilla.gnome.org/show_bug.cgi?id=311057
+ // See also https://bugzilla.gnome.org/show_bug.cgi?id=738602
+ call_ = nullptr;
+
+ if (parent_)
+ {
+ auto data_ = parent_;
+ parent_ = nullptr; // Just a precaution.
+ (cleanup_)(data_); // Notify the parent (might lead to destruction of this!).
+ }
+}
+
+//static
+void* slot_rep::notify(void* data)
+{
+ auto self_ = reinterpret_cast<slot_rep*>(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);
+ self_->disconnect(); // Disconnect the slot (might lead to deletion of self_!).
+ // If self_ has been deleted, the destructor has called destroy().
+ if (!notifier.deleted_)
+ {
+ 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.
+ }
+ 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_)
+{
+ 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.
+ if (src.rep_->call_)
+ rep_ = src.rep_->dup();
+ else
+ {
+ *this = slot_base(); //Return the default invalid slot.
+ }
+ }
+}
+
+slot_base::slot_base(slot_base&& src)
+: rep_(nullptr),
+ blocked_(src.blocked_)
+{
+ if (src.rep_)
+ {
+ if (src.rep_->parent_)
+ {
+ // 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().
+ if (src.rep_->call_)
+ rep_ = src.rep_->dup();
+ else
+ blocked_ = false; //Return the default invalid slot.
+ }
+ else
+ {
+ // src is not connected. Really move src.rep_.
+ src.rep_->notify_callbacks();
+ rep_ = src.rep_;
+
+ //Wipe src:
+ src.rep_ = nullptr;
+ src.blocked_ = false;
+ }
+ }
+}
+
+slot_base::~slot_base()
+{
+ if (rep_)
+ delete rep_;
+}
+
+slot_base::operator bool() const noexcept
+{
+ return rep_ != nullptr;
+}
+
+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);
+ 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_)
+ {
+ 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)
+{
+ if (src.rep_ == rep_)
+ {
+ blocked_ = src.blocked_;
+ return *this;
+ }
+
+ if (src.empty())
+ {
+ delete_rep_with_check();
+
+ return *this;
+ }
+
+ auto new_rep_ = src.rep_->dup();
+
+ if (rep_) // Silently exchange the slot_rep.
+ {
+ new_rep_->set_parent(rep_->parent_, rep_->cleanup_);
+ delete rep_; // Calls destroy(), but does not call disconnect().
+ }
+
+ rep_ = new_rep_;
+ blocked_ = src.blocked_;
+
+ return *this;
+}
+
+slot_base& slot_base::operator=(slot_base&& src)
+{
+ if (src.rep_ == rep_)
+ {
+ blocked_ = src.blocked_;
+ return *this;
+ }
+
+ if (src.empty())
+ {
+ delete_rep_with_check();
+ return *this;
+ }
+
+ blocked_ = src.blocked_;
+ internal::slot_rep* new_rep_ = nullptr;
+ if (src.rep_->parent_)
+ {
+ // 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();
+ }
+ else
+ {
+ // src is not connected. Really move src.rep_.
+ src.rep_->notify_callbacks();
+ new_rep_ = src.rep_;
+
+ //Wipe src:
+ src.rep_ = nullptr;
+ src.blocked_ = false;
+ }
+
+ if (rep_) // Silently exchange the slot_rep.
+ {
+ new_rep_->set_parent(rep_->parent_, rep_->cleanup_);
+ delete rep_; // Calls destroy(), but does not call disconnect().
+ }
+ rep_ = new_rep_;
+ return *this;
+}
+
+void slot_base::set_parent(void* parent, void* (*cleanup)(void*)) const noexcept
+{
+ 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
+{
+ if (rep_)
+ rep_->add_destroy_notify_callback(data, func);
+}
+
+void slot_base::remove_destroy_notify_callback(void* data) const
+{
+ if (rep_)
+ rep_->remove_destroy_notify_callback(data);
+}
+
+bool slot_base::block(bool should_block) noexcept
+{
+ bool old = blocked_;
+ blocked_ = should_block;
+ return old;
+}
+
+bool slot_base::unblock() noexcept
+{
+ return block(false);
+}
+
+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_)
+ {
+ delete rep_; // This is not strictly necessary here. I'm convinced that it is
+ rep_ = nullptr; // safe to wait for the destructor to delete the slot_rep. Martin.
+ }
+ return (rep_ == nullptr);
+}*/
+
+} //namespace sigc
--- /dev/null
+/*
+ * Copyright 2003, 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
+ *
+ */
+#ifndef _SIGC_SLOT_BASE_HPP_
+#define _SIGC_SLOT_BASE_HPP_
+
+#include <sigc++config.h>
+#include <sigc++/trackable.h>
+#include <sigc++/functors/functor_trait.h>
+
+namespace sigc
+{
+
+namespace internal {
+
+typedef void* (*hook)(void*);
+
+/** Internal representation of a slot.
+ * Derivations of this class can be considered as a link
+ * between a slot and the functor that the slot should
+ * execute in operator(). This link is needed because in
+ * libsigc++ the slot doesn't necessarily have exactly the
+ * same function signature as the functor, thus allowing for
+ * implicit conversions.
+ *
+ * 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()),
+ * - 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(),
+ * -# a generic function pointer, call_, that is simply
+ * set to zero in notify() 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
+{
+ slot_rep(const slot_rep& src) = delete;
+ slot_rep& operator=(const slot_rep& src) = delete;
+
+ slot_rep(slot_rep&& src) = delete;
+ slot_rep& operator=(slot_rep&& src) = delete;
+
+ /* 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. */
+
+ /// 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 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_;
+
+ /** 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
+#ifdef SIGC_NEW_DELETE_IN_LIBRARY_ONLY
+ void* operator new(size_t size_);
+ void operator delete(void* p);
+#endif
+
+ /** Destroys the slot_rep object (but doesn't delete it).
+ */
+ inline void destroy()
+ { if (destroy_) (*destroy_)(this); }
+
+ /** 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<slot_rep*>((*dup_)(const_cast<slot_rep*>(this))); }
+
+ /** Set the parent with a callback.
+ * slots have one parent exclusively.
+ * @param parent The new parent.
+ * @param cleanup The callback to execute from notify().
+ */
+ inline void set_parent(void* parent, hook cleanup) noexcept
+ {
+ parent_ = parent;
+ cleanup_ = cleanup;
+ }
+
+ /// Invalidates the slot and executes the parent's cleanup callback.
+ void disconnect();
+
+ /** Callback that invalidates the slot.
+ * This callback is registered in every object of a trackable
+ * inherited type that is referred by this slot_rep object.
+ * It is executed when the slot becomes invalid because of some
+ * referred object dying.
+ * @param data The slot_rep object that is becoming invalid (@p this).
+ */
+ static void* notify(void* data);
+};
+
+/** Functor used to add a dependency to a trackable.
+ * Consequently slot_rep::notify() gets executed when the
+ * trackable is destroyed or overwritten.
+ */
+struct SIGC_API slot_do_bind
+{
+ /** The slot_rep object trackables should notify on destruction. */
+ slot_rep* rep_;
+
+ /** 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) {}
+
+ /** 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); }
+};
+
+/// Functor used to remove a dependency from a trackable.
+struct SIGC_API slot_do_unbind
+{
+ /** The slot_rep object trackables don't need to notify on destruction any more. */
+ slot_rep* rep_;
+
+ /** 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) {}
+
+ /** 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_); }
+};
+
+} //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.
+ *
+ * @section slots-creating Creating Slots
+ *
+ * Use the sigc::mem_fun() or sigc::ptr_fun() template functions to get a sigc::slot, like so:
+ * @code
+ * sigc::slot<void, int> sl = sigc::mem_fun(someobj, &SomeClass::somemethod);
+ * @endcode
+ * or
+ * @code
+ * sigc::slot<void, int> sl = sigc::ptr_fun(&somefunction);
+ * @endcode
+ * or, in gtkmm,
+ * @code
+ * m_Button.signal_clicked().connect( sigc::mem_fun(*this, &MyWindow::on_button_clicked) );
+ * @endcode
+ *
+ * The compiler will complain if SomeClass::somemethod, etc. have the wrong signature.
+ *
+ * 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<void, int> 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 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
+ * auto on_response = [&someobj] (int response_id)
+ * {
+ * someobj.somemethod(response_id);
+ * somefunction(response_id);
+ * };
+ * m_Dialog.signal_response().connect(on_response);
+ * @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().
+ *
+ * @ingroup sigcfunctors
+ */
+
+/** Base type for slots.
+ * slot_base integrates most of the interface of the derived
+ * sigc::slot templates. 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
+ * 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
+{
+ typedef internal::slot_rep rep_type;
+
+ // Move operations are not declared noexcept because
+ // 1. they may copy instead of move
+ // 2. when they don't copy, they call src.rep_->notify_callbacks(), which
+ // may throw an exception.
+public:
+ /// Constructs an empty slot.
+ slot_base() noexcept;
+
+ /** Constructs a slot from an existing slot_rep object.
+ * @param rep The slot_rep object this slot should contain.
+ */
+ explicit slot_base(rep_type* rep) noexcept;
+
+ /** Constructs a slot, copying an existing one.
+ * @param src The existing slot to copy.
+ */
+ slot_base(const 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_base(slot_base&& src);
+
+ ~slot_base();
+
+ /** Tests whether a slot is null, because the default constructor was used.
+ * Test a slot for null like so:
+ * @code
+ * if(slot)
+ * do_something()
+ * @endcode
+ */
+ explicit operator bool() const noexcept;
+
+ /** 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
+ * because of some referred object dying.
+ * @param parent The new parent.
+ * @param cleanup The notification callback.
+ */
+ void set_parent(void* parent, void* (*cleanup)(void*)) const noexcept;
+
+ typedef trackable::func_destroy_notify func_destroy_notify;
+ /** Add a callback that is executed (notified) when the slot is detroyed.
+ * 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;
+
+ /** 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;
+
+ /** Returns whether the slot is invalid.
+ * @return @p true if the slot is invalid (empty).
+ */
+ 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_; }
+
+ /** 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
+ * contained by this slot until unblock() or block() with
+ * @e should_block = @p false is called.
+ * @param should_block Indicates whether the blocking state should be set or unset.
+ * @return @p true if the slot was in blocking state before.
+ */
+ bool block(bool should_block = true) noexcept;
+
+ /** Unsets the blocking state.
+ * @return @p true if the slot was in blocking state before.
+ */
+ bool unblock() noexcept;
+
+ /** Disconnects the slot.
+ * Invalidates the slot and notifies the parent.
+ */
+ 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:
+ /** Overrides this slot, making a copy from another slot.
+ * @param src The slot from which to make a copy.
+ * @return @p this.
+ */
+ slot_base& operator=(const slot_base& src);
+
+ /** 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_base& operator=(slot_base&& src);
+
+public: // public to avoid template friend declarations
+ /** Typed slot_rep object that contains a functor. */
+ mutable rep_type *rep_;
+
+ /** Indicates whether the slot is blocked. */
+ bool blocked_;
+
+private:
+ void delete_rep_with_check();
+};
+
+} //namespace sigc
+
+#endif //_SIGC_SLOT_BASE_HPP_
+
--- /dev/null
+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<Foo> 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 <class T_type,
+ bool I_derives_trackable =
+ std::is_base_of<trackable, T_type>::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 T_type>
+class [$1]limit_reference<T_type, true>
+{
+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 <class T_type, bool I_derives_trackable>
+struct visitor<[$1]limit_reference<T_type, I_derives_trackable> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const [$1]limit_reference<T_type, I_derives_trackable>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.visit());
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+])
+
+divert(0)
+
+_FIREWALL([LIMIT_REFERENCE])
+
+#include <sigc++/visit_each.h>
+#include <sigc++/type_traits.h>
+#include <sigc++/trackable.h>
+
+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 */
+
--- /dev/null
+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 <LIST(class T_return, LOOP(class T_arg%1, $1), class T_accumulator)>
+struct signal_emit$1
+{
+ typedef signal_emit$1<LIST(T_return, LOOP(T_arg%1, $1), T_accumulator)> self_type;
+ typedef typename T_accumulator::result_type result_type;
+ typedef slot<T_return(LIST(LOOP(T_arg%1, $1)))> slot_type;
+ typedef internal::slot_iterator_buf<self_type, T_return> slot_iterator_buf_type;
+ typedef internal::slot_reverse_iterator_buf<self_type, T_return> 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<T_arg%1> _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 (sigc::internal::function_pointer_cast<typename slot_type::call_type>(_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<T_arg%1> _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));
+ }
+
+_DEPRECATE_IFDEF_START
+ /** 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.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ static result_type emit_reverse(LIST(signal_impl* impl, LOOP(type_trait_take_t<T_arg%1> _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));
+ }
+_DEPRECATE_IFDEF_END
+
+dnl
+ FOR(1, $1,[
+ type_trait_take_t<T_arg%1> _A_a%1_;])
+};
+
+/** Abstracts signal emission.
+ * This template specialization implements an optimized emit()
+ * function for the case that no accumulator is used.
+ */
+template <LIST(class T_return, LOOP(class T_arg%1, $1))>
+struct signal_emit$1<LIST(T_return, LOOP(T_arg%1, $1), nil)>
+{
+ typedef signal_emit$1<LIST(T_return, LOOP(T_arg%1, $1), nil) > self_type;
+ typedef T_return result_type;
+ typedef slot<T_return(LIST(LOOP(T_arg%1, $1)))> 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<T_arg%1> _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_);
+ auto 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_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(LIST(it->rep_, LOOP(_A_a%1, $1)));
+ for (++it; it != slots.end(); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(LIST(it->rep_, LOOP(_A_a%1, $1)));
+ }
+ }
+
+ return r_;
+ }
+
+_DEPRECATE_IFDEF_START
+ /** 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.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ static result_type emit_reverse(LIST(signal_impl* impl, LOOP(type_trait_take_t<T_arg%1> _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<signal_impl::iterator_type> reverse_iterator_type;
+#else
+ typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
+ slot_base, slot_base&, slot_base*, std::ptrdiff_t> 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_ = (sigc::internal::function_pointer_cast<call_type>(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_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(LIST(it->rep_, LOOP(_A_a%1, $1)));
+ }
+ }
+
+ return r_;
+ }
+_DEPRECATE_IFDEF_END
+};
+
+/** 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 <LOOP(class T_arg%1, $1)>
+struct signal_emit$1<LIST(void, LOOP(T_arg%1, $1), nil)>
+{
+ typedef signal_emit$1<LIST(void, LOOP(T_arg%1, $1), nil)> self_type;
+ typedef void result_type;
+ typedef slot<void(LIST(LOOP(T_arg%1, $1)))> 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<T_arg%1> _A_a%1, $1)))
+ {
+ if (!impl || impl->slots_.empty()) return;
+ signal_exec exec(impl);
+ temp_slot_list slots(impl->slots_);
+
+ for (const auto& slot : slots)
+ {
+ if (slot.empty() || slot.blocked())
+ continue;
+ (sigc::internal::function_pointer_cast<call_type>(slot.rep_->call_))(LIST(slot.rep_, LOOP(_A_a%1, $1)));
+ }
+ }
+
+_DEPRECATE_IFDEF_START
+ /** 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.])
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ static result_type emit_reverse(LIST(signal_impl* impl, LOOP(type_trait_take_t<T_arg%1> _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<signal_impl::iterator_type> reverse_iterator_type;
+#else
+ typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
+ slot_base, slot_base&, slot_base*, std::ptrdiff_t> reverse_iterator_type;
+#endif
+ for (auto it = reverse_iterator_type(slots.end()); it != reverse_iterator_type(slots.begin()); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(LIST(it->rep_, LOOP(_A_a%1, $1)));
+ }
+ }
+_DEPRECATE_IFDEF_END
+};
+
+])
+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.
+ *
+ * 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 <LIST(class T_return, LOOP(class T_arg%1, $1), class T_accumulator=nil)>
+class signal$1
+ : public signal_base
+{
+public:
+ typedef internal::signal_emit$1<LIST(T_return, LOOP(T_arg%1, $1), T_accumulator)> emitter_type;
+ typedef typename emitter_type::result_type result_type;
+ typedef slot<T_return(LIST(LOOP(T_arg%1, $1)))> slot_type;
+ typedef slot_list<slot_type> 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<const slot_base&>(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_base&>(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<T_arg%1> _A_a%1, $1)) const
+ { return emitter_type::emit(LIST(impl_, LOOP(_A_a%1, $1))); }
+
+_DEPRECATE_IFDEF_START
+ /** Triggers the emission of the signal in reverse order (see emit()).
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ result_type emit_reverse(LOOP(type_trait_take_t<T_arg%1> _A_a%1, $1)) const
+ { return emitter_type::emit_reverse(LIST(impl_, LOOP(_A_a%1, $1))); }
+_DEPRECATE_IFDEF_END
+
+ /** Triggers the emission of the signal (see emit()).
+ *
+ * @deprecated This is apparently not useful, but let us know if you need it.
+ */
+ result_type operator()(LOOP(type_trait_take_t<T_arg%1> _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<LIST(result_type, signal$1, LOOP(type_trait_take_t<T_arg%1>, $1))> make_slot() const
+ { return bound_const_mem_functor$1<LIST(result_type, signal$1, LOOP(type_trait_take_t<T_arg%1>, $1))>(*this, &signal$1::emit); }
+
+_DEPRECATE_IFDEF_START
+ /** 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.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ 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.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ const slot_list_type slots() const
+ { return slot_list_type(const_cast<signal$1*>(this)->impl()); }
+_DEPRECATE_IFDEF_END
+
+ 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!
+ *
+ * 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<void, long> sig;
+ * sig.connect(sigc::ptr_fun(&foo));
+ * sig.emit(19);
+ * @endcode
+ *
+ * @deprecated Please use the syntax similar to that used by std::function<>:
+ * @code
+ * sigc::slot<void(bool, int)> some_slot;
+ * @endcode
+ *
+ * @ingroup signal
+ */
+template <LIST(class T_return, LOOP(class T_arg%1 = nil, $1))>
+class signal],[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).
+ *
+ * @deprecated Please use the syntax similar to that used by std::function<>:
+ * @code
+ * sigc::slot<void(bool, int)> some_slot;
+ * @endcode
+ifelse($1, $2,[dnl
+ *
+ * @ingroup signal
+])dnl
+ */
+template <LIST(class T_return, LOOP(class T_arg%1, $1))>
+class signal ifelse($1, $2,,[<LIST(T_return, LOOP(T_arg%1,$1), LOOP(nil, CALL_SIZE - $1))>])])
+ : public signal$1<LIST(T_return, LOOP(T_arg%1, $1),nil)>
+{
+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<typename T_iterator>
+ * 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<typename T_iterator>
+ * 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 T_accumulator>
+ class accumulated
+ : public signal$1<LIST(T_return, LOOP(T_arg%1, $1), T_accumulator)>
+ {
+ public:
+ accumulated() {}
+ accumulated(const accumulated& src)
+ : signal$1<LIST(T_return, LOOP(T_arg%1, $1), T_accumulator)>(src) {}
+ };
+
+ signal() {}
+
+ signal(const signal& src)
+ : signal$1<LIST(T_return, LOOP(T_arg%1, $1),nil)>(src) {}
+
+ signal(signal&& src)
+ : signal$1<LIST(T_return, LOOP(T_arg%1, $1),nil)>(std::move(src)) {}
+
+ signal& operator=(const signal& src)
+ {
+ signal$1<LIST(T_return, LOOP(T_arg%1, $1),nil)>::operator=(src);
+ return *this;
+ }
+
+ signal& operator=(signal&& src)
+ {
+ signal$1<LIST(T_return, LOOP(T_arg%1, $1),nil)>::operator=(std::move(src));
+ return *this;
+ }
+};
+
+/**
+ * This specialization allow use of the sigc::signal<R(Args...)> syntax,
+ */
+template <LIST(class T_return, LOOP(class T_arg%1, $1))>
+class signal<T_return(LIST(LOOP(T_arg%1, $1)))>
+ : public signal$1<LIST(T_return, LOOP(T_arg%1, $1),nil)>
+{
+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<typename T_iterator>
+ * 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<typename T_iterator>
+ * 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 T_accumulator>
+ class accumulated
+ : public signal$1<LIST(T_return, LOOP(T_arg%1, $1), T_accumulator)>
+ {
+ public:
+ accumulated() {}
+ accumulated(const accumulated& src)
+ : signal$1<LIST(T_return, LOOP(T_arg%1, $1), T_accumulator)>(src) {}
+ };
+
+ signal() {}
+
+ signal(const signal& src)
+ : signal$1<LIST(T_return, LOOP(T_arg%1, $1),nil)>(src) {}
+
+ signal(signal&& src)
+ : signal$1<LIST(T_return, LOOP(T_arg%1, $1),nil)>(std::move(src)) {}
+
+ signal& operator=(const signal& src)
+ {
+ signal$1<LIST(T_return, LOOP(T_arg%1, $1),nil)>::operator=(src);
+ return *this;
+ }
+
+ signal& operator=(signal&& src)
+ {
+ signal$1<LIST(T_return, LOOP(T_arg%1, $1),nil)>::operator=(std::move(src));
+ return *this;
+ }
+};
+
+
+])
+
+divert(0)
+#ifndef _SIGC_SIGNAL_H_
+#define _SIGC_SIGNAL_H_
+
+#include <list>
+#include <sigc++/signal_base.h>
+#include <sigc++/type_traits.h>
+#include <sigc++/trackable.h>
+#include <sigc++/functors/slot.h>
+#include <sigc++/functors/mem_fun.h>
+
+//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 <typename T_slot>
+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<reference>(*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 <typename T_slot>
+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<reference>(*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.
+ *
+ * @ingroup signal
+ */
+template <class T_slot>
+struct slot_list
+{
+ typedef T_slot slot_type;
+
+ typedef slot_type& reference;
+ typedef const slot_type& const_reference;
+
+ typedef slot_iterator<slot_type> iterator;
+ typedef slot_const_iterator<slot_type> const_iterator;
+
+ #ifndef SIGC_HAVE_SUN_REVERSE_ITERATOR
+ typedef std::reverse_iterator<iterator> reverse_iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+ #else
+ typedef std::reverse_iterator<iterator, std::random_access_iterator_tag,
+ int, int&, int*, std::ptrdiff_t> reverse_iterator;
+
+ typedef std::reverse_iterator<const_iterator, std::random_access_iterator_tag,
+ int, const int&, const int*, std::ptrdiff_t> 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<const slot_base&>(slot_))); }
+
+ iterator insert(iterator i, slot_type&& slot_)
+ { return iterator(list_->insert(i.i_, std::move(static_cast<slot_base&>(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 <class T_emitter, class T_result = typename T_emitter::result_type>
+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<const slot_type&>(*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 <class T_emitter>
+struct slot_iterator_buf<T_emitter, void>
+{
+ 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<const slot_type&>(*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 <class T_emitter, class T_result = typename T_emitter::result_type>
+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
+ {
+ auto __tmp(i_);
+ --__tmp;
+ if (!__tmp->empty() && !__tmp->blocked() && !invoked_)
+ {
+ r_ = (*c_)(static_cast<const slot_type&>(*__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 <class T_emitter>
+struct slot_reverse_iterator_buf<T_emitter, void>
+{
+ 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
+ {
+ auto __tmp(i_);
+ --__tmp;
+ if (!__tmp->empty() && !__tmp->blocked() && !invoked_)
+ {
+ (*c_)(static_cast<const slot_type&>(*__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_ */
--- /dev/null
+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
--- /dev/null
+# sigc++
+
+# Input: sigcxx_build_dep, sigcxx_pcname, sigcxx_libversion, sigcxx_api_version,
+# install_includedir, project_source_root, sigc_res, python3,
+# handle_built_files, maintainer_mode, can_add_dist_script
+# Output: source_h_files, built_h_files, sigcxx_own_dep, built_files_root,
+# built_h_file_targets
+
+source_cc_files = [
+ 'connection.cc',
+ 'signal_base.cc',
+ 'trackable.cc',
+ 'functors' / 'slot_base.cc',
+]
+
+sigc_h_files = [
+ 'bind.h',
+ 'bind_return.h',
+ 'connection.h',
+ 'reference_wrapper.h',
+ 'retype_return.h',
+ 'signal_base.h',
+ 'slot.h',
+ 'trackable.h',
+ 'type_traits.h',
+ 'visit_each.h',
+]
+adaptors_h_files = [
+ 'adaptors' / 'adaptors.h',
+ 'adaptors' / 'bound_argument.h',
+]
+functors_h_files = [
+ 'functors' / 'functors.h',
+ 'functors' / 'slot_base.h',
+]
+
+# .m4 files to build .h files from.
+sigc_h_m4_files = [
+ 'limit_reference.h',
+ 'signal.h',
+]
+
+m4_template = files('macros' / 'template.macros.m4')
+m4_include_dir = meson.current_source_dir() / 'macros'
+
+source_h_files = sigc_h_files + adaptors_h_files + functors_h_files
+
+built_h_files = sigc_h_m4_files
+built_cc_files = []
+
+# Force meson+ninja to generate source files before anything is compiled.
+# Compilation must depend on these targets.
+built_cc_file_targets = []
+built_h_file_targets = []
+
+subdir('adaptors')
+subdir('adaptors/lambda')
+subdir('functors')
+
+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')
+
+untracked_sigcxx = 'untracked' / 'sigc++'
+src_untracked_sigcxx = project_source_root / untracked_sigcxx
+
+extra_sigc_cppflags = []
+extra_sigc_objects = []
+
+# Make sure we are exporting the symbols from the DLL
+if is_msvc
+ extra_sigc_cppflags += ['-DSIGC_BUILD', '-D_WINDLL']
+endif
+
+# Build the .rc file for Windows builds and link to it
+if host_machine.system() == 'windows'
+ windows = import('windows')
+ sigc_res = windows.compile_resources(sigc_rc)
+ extra_sigc_objects += sigc_res
+endif
+
+if maintainer_mode
+
+ # Maintainer mode. Generate .h and .cc files from .m4 files in macros/ directory.
+ # .h and .cc files are also generated in subdirectories.
+
+ # docs/reference/meson.build needs this.
+ built_files_root = project_build_root
+
+ foreach file : sigc_h_m4_files
+ built_h_file_targets += custom_target(file,
+ input: 'macros' / file + '.m4',
+ output: file,
+ command: [
+ python3, handle_built_files, 'build_from_m4',
+ m4_include_dir,
+ '@INPUT@',
+ '@OUTPUT@',
+ ],
+ depend_files: m4_template,
+ build_by_default: maintainer_mode,
+ install: false,
+ )
+ endforeach
+
+ extra_include_dirs = ['..']
+ sigcxx_library = library('sigc-' + sigcxx_api_version,
+ source_cc_files, built_cc_file_targets, built_h_file_targets,
+ extra_sigc_objects,
+ version: sigcxx_libversion,
+ darwin_versions: darwin_versions,
+ cpp_args: extra_sigc_cppflags,
+ implicit_include_directories: false,
+ include_directories: extra_include_dirs,
+ dependencies: sigcxx_build_dep,
+ install: true,
+ )
+
+ built_h_cc_dir = meson.current_build_dir()
+
+else # not maintainer_mode
+
+ # Not maintainer mode. Compile built source code files in
+ # project_source_root/untracked/sigc++.
+
+ # docs/reference/meson.build needs this.
+ built_files_root = project_source_root / 'untracked'
+
+ # Two cases:
+ # 1. The source code comes from a tarball, where the built files
+ # are stored in project_source_root/untracked.
+ # There are no built files in the build tree.
+ # 2. Files have been built in the build tree. Then maintainer_mode has
+ # been changed from true to false. Files that are missing or not up to date
+ # in project_source_root/untracked are copied from the build tree.
+
+ # Try to copy built source code files to the source tree.
+ run_command(
+ python3, handle_built_files, 'copy_built_files',
+ meson.current_build_dir(),
+ src_untracked_sigcxx,
+ built_h_files + built_cc_files,
+ check: true,
+ )
+
+ untracked_built_cc_files = []
+ foreach file : built_cc_files
+ untracked_built_cc_files += '..' / 'untracked' / 'sigc++' / file
+ endforeach
+
+ extra_include_dirs = [ '..', '..' / 'untracked' ]
+ sigcxx_library = library('sigc-' + sigcxx_api_version,
+ source_cc_files, untracked_built_cc_files,
+ extra_sigc_objects,
+ version: sigcxx_libversion,
+ darwin_versions: darwin_versions,
+ cpp_args: extra_sigc_cppflags,
+ implicit_include_directories: false,
+ include_directories: extra_include_dirs,
+ dependencies: sigcxx_build_dep,
+ install: true,
+ )
+
+ built_h_cc_dir = src_untracked_sigcxx
+
+endif
+
+# Install built .h files.
+meson.add_install_script(
+ python3, handle_built_files, 'install_built_h_files',
+ built_h_cc_dir,
+ install_includedir / sigcxx_pcname / 'sigc++', # subdir below {prefix}
+ built_h_files,
+)
+
+if can_add_dist_script
+ # Distribute built files.
+ meson.add_dist_script(
+ python3, handle_built_files, 'dist_built_files',
+ built_h_cc_dir,
+ untracked_sigcxx,
+ built_h_files + built_cc_files,
+ )
+endif
+
+# 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(
+ sources: built_h_file_targets,
+ link_with: sigcxx_library,
+ include_directories: extra_include_dirs,
+ dependencies: sigcxx_build_dep
+)
--- /dev/null
+/*
+ * 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
+ *
+ */
+#ifndef _SIGC_REFERENCE_WRAPPER_H_
+#define _SIGC_REFERENCE_WRAPPER_H_
+
+#include <functional> // For std::reference_wrapper.
+
+namespace sigc {
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+
+/** Reference wrapper.
+ * Use sigc::ref() to create a reference wrapper.
+ *
+ * @deprecated Use std::ref() or std::cref() instead to create a std::reference_wrapper().
+ */
+template <class T_type>
+struct reference_wrapper
+{
+ explicit reference_wrapper(T_type& v)
+ : value_(v) {}
+
+ operator T_type& () const
+ { return value_; }
+
+ T_type& value_;
+};
+
+/** Const reference wrapper.
+ * Use sigc::ref() to create a const reference wrapper.
+ *
+ * @deprecated Use std::ref() or std::cref() instead to create a std::reference_wrapper().
+ */
+template <class T_type>
+struct const_reference_wrapper
+{
+ 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.
+ *
+ * @deprecated Use std::ref() or std::cref() instead.
+ */
+template <class T_type>
+reference_wrapper<T_type> ref(T_type& v)
+{ return reference_wrapper<T_type>(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.
+ *
+ * @deprecated Use std::ref() or std::cref() instead.
+ */
+template <class T_type>
+const_reference_wrapper<T_type> ref(const T_type& v)
+{ return const_reference_wrapper<T_type>(v); }
+
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+
+template <class T_type>
+struct unwrap_reference
+{
+ typedef T_type type;
+};
+
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+
+// Specializations for std::reference_wrapper and std::const_reference_wrapper:
+
+template <class T_type>
+struct unwrap_reference<reference_wrapper<T_type> >
+{
+ typedef T_type& type;
+};
+
+template <class T_type>
+struct unwrap_reference<const_reference_wrapper<T_type> >
+{
+ typedef const T_type& type;
+};
+
+template <class T_type>
+T_type& unwrap(const reference_wrapper<T_type>& v)
+{ return v; }
+
+template <class T_type>
+const T_type& unwrap(const const_reference_wrapper<T_type>& v)
+{ return v; }
+
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+//Specializations for std::reference_wrapper:
+
+template <class T_type>
+struct unwrap_reference<std::reference_wrapper<T_type> >
+{
+ typedef T_type& type;
+};
+
+template <class T_type>
+T_type& unwrap(const std::reference_wrapper<T_type>& v)
+{ return v; }
+
+} /* namespace sigc */
+
+#endif /* _SIGC_REFERENCE_WRAPPER_H_ */
--- /dev/null
+/*
+ * 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
+ *
+ */
+#ifndef _SIGC_RETYPE_RETURN_HPP_
+#define _SIGC_RETYPE_RETURN_HPP_
+
+#include <sigc++/adaptors/retype_return.h>
+
+
+#endif /* _SIGC_RETYPE_RETURN_HPP_ */
--- /dev/null
+/*
+ * Copyright 2003, 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
+ *
+ */
+
+#ifndef SIGCXX_SIGCXX_H
+#define SIGCXX_SIGCXX_H
+
+/** @mainpage libsigc++ Reference Manual
+ *
+ * @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
+ * dissimilar callbacks.
+ *
+ * For instance, see the @ref signal "Signals", @ref sigcfunctors "Functors",
+ * @ref slot "Slots" and @ref adaptors "Adaptors".
+ *
+ * See also the
+ * <a href="https://developer.gnome.org/libsigc++-tutorial/2.10/">libsigc++ tutorial</a>,
+ * the <a href="https://libsigcplusplus.github.io/libsigcplusplus/">libsigc++ website</a>, and
+ * the <a href="https://developer.gnome.org/gtkmm-tutorial/3.24/chapter-signals.html">Signals appendix of the Programming with gtkmm book</a>.
+ *
+ * @section features Features
+ *
+ * - Compile-time typesafe callbacks (also faster than run time checks)
+ * - 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
+ * cause crashes)
+ * - 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, and compose
+ *
+ * @section basics Basic Usage
+ *
+ * Include the libsigc++ header:
+ * @code
+ * #include <sigc++/sigc++.h>
+ * @endcode
+ * (You may include individual headers, such as @c sigc++/bind.h instead.)
+ *
+ * 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`
+ * @endcode
+ * If your version of g++ is not C++11-compliant by default,
+ * add the @c -std=c++11 option.
+ *
+ * @subsection meson Using Meson
+ *
+ * If using <a href="https://mesonbuild.com/">Meson</a>, include the following
+ * in @c meson.build:
+ * @code
+ * sigc_dep = dependency('sigc++-2.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([DEPS], [sigc++-2.0])
+ * @endcode
+ * Then use the generated @c DEPS_CFLAGS and @c DEPS_LIBS variables
+ * in the project @c Makefile.am files. For example:
+ * @code
+ * yourprogram_CPPFLAGS = $(DEPS_CFLAGS)
+ * yourprogram_LDADD = $(DEPS_LIBS)
+ * @endcode
+ *
+ * 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++-2.0)
+ * include_directories(${DEPS_INCLUDE_DIRS})
+ * target_link_libraries(yourprogram ${DEPS_LIBRARIES})
+ * @endcode
+ *
+ * Your @c pkg_check_modules() call should also mention any other libraries that
+ * you need to use via pkg-config.
+ *
+ * @section scope Scope of Documentation
+ *
+ * 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.
+ */
+
+#include <sigc++/signal.h>
+#include <sigc++/connection.h>
+#include <sigc++/trackable.h>
+#include <sigc++/adaptors/adaptors.h>
+#include <sigc++/functors/functors.h>
+
+#endif /* SIGCXX_SIGCXX_H */
--- /dev/null
+/*
+ * Copyright 2003, 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 <sigc++/signal_base.h>
+#include <memory> // std::unique_ptr
+
+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()
+// when the slot is disconnected. Bug 167714.
+struct self_and_iter
+{
+ signal_impl* self_;
+ signal_impl::iterator_type iter_;
+
+ self_and_iter(signal_impl* self, signal_impl::iterator_type iter)
+ : self_(self), iter_(iter) {}
+};
+
+signal_impl::signal_impl()
+: ref_count_(0), exec_count_(0), deferred_(false)
+{}
+
+// 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_)
+{
+ return malloc(size_);
+}
+
+void signal_impl::operator delete(void* p)
+{
+ free(p);
+}
+#endif
+
+void signal_impl::clear()
+{
+ // Don't let signal_impl::notify() erase the slots. It would invalidate the
+ // iterator in the following loop.
+ const bool during_signal_emission = exec_count_ > 0;
+ const bool saved_deferred = deferred_;
+ signal_exec exec(this);
+
+ // Disconnect all connected slots before they are deleted.
+ // signal_impl::notify() will be called and delete the self_and_iter structs.
+ for (auto& slot : slots_)
+ slot.disconnect();
+
+ // Don't clear slots_ during signal emission. Provided deferred_ is true,
+ // sweep() will be called from ~signal_exec() 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
+{
+ return slots_.size();
+}
+
+bool signal_impl::blocked() const noexcept
+{
+ for (const auto& slot : const_cast<const std::list<slot_base>&>(slots_))
+ {
+ if (!slot.blocked())
+ return false;
+ }
+ return true;
+}
+
+void signal_impl::block(bool should_block) noexcept
+{
+ for (auto& slot : slots_)
+ {
+ slot.block(should_block);
+ }
+}
+
+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_)
+{
+ return insert(slots_.end(), std::move(slot_));
+}
+
+signal_impl::iterator_type signal_impl::erase(iterator_type i)
+{
+ // 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();
+
+ deferred_ = saved_deferred;
+
+ return slots_.erase(i);
+}
+
+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;
+}
+
+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;
+}
+
+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);
+
+ 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)
+{
+ std::unique_ptr<self_and_iter> si(static_cast<self_and_iter*>(d));
+
+ if (si->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_);
+ }
+ 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(const signal_base& src) noexcept
+: trackable(),
+ impl_(src.impl())
+{
+ impl_->reference();
+}
+
+signal_base::signal_base(signal_base&& src)
+: trackable(std::move(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();
+ }
+}
+
+void signal_base::clear()
+{
+ if (impl_)
+ impl_->clear();
+}
+
+signal_base::size_type signal_base::size() const noexcept
+{
+ return (impl_ ? impl_->size() : 0);
+}
+
+bool signal_base::blocked() const noexcept
+{
+ return (impl_ ? impl_->blocked() : true);
+}
+
+void signal_base::block(bool should_block) noexcept
+{
+ if (impl_)
+ impl_->block(should_block);
+}
+
+void signal_base::unblock() noexcept
+{
+ if (impl_)
+ impl_->block(false);
+}
+
+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_)
+{
+ return impl()->connect(std::move(slot_));
+}
+
+signal_base::iterator_type signal_base::insert(iterator_type i, const slot_base& slot_)
+{
+ return impl()->insert(i, slot_);
+}
+
+signal_base::iterator_type signal_base::insert(iterator_type i, slot_base&& slot_)
+{
+ return impl()->insert(i, std::move(slot_));
+}
+
+signal_base::iterator_type signal_base::erase(iterator_type i)
+{
+ return impl()->erase(i);
+}
+
+signal_base& signal_base::operator=(const signal_base& src)
+{
+ 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();
+ }
+ impl_ = src.impl();
+ impl_->reference();
+ return *this;
+}
+
+signal_base& signal_base::operator=(signal_base&& src)
+{
+ 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
+{
+ if (!impl_) {
+ impl_ = new internal::signal_impl;
+ impl_->reference(); // start with a reference count of 1
+ }
+ return impl_;
+}
+
+} /* sigc */
--- /dev/null
+/*
+ * 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
+ */
+
+#ifndef _SIGC_SIGNAL_BASE_H_
+#define _SIGC_SIGNAL_BASE_H_
+
+#include <cstddef>
+#include <list>
+#include <sigc++config.h>
+#include <sigc++/type_traits.h>
+#include <sigc++/trackable.h>
+#include <sigc++/functors/slot.h>
+#include <sigc++/functors/mem_fun.h>
+
+/** The libsigc++ namespace.
+ */
+namespace sigc
+{
+
+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.
+ */
+struct SIGC_API signal_impl
+{
+ typedef std::size_t size_type;
+ typedef std::list<slot_base> slot_list;
+ typedef slot_list::iterator iterator_type;
+ typedef slot_list::const_iterator const_iterator_type;
+
+ signal_impl();
+
+ signal_impl(const signal_impl& src) = delete;
+ signal_impl& operator=(const signal_impl& src) = delete;
+
+ 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
+#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; }
+
+ /** 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();
+ }
+
+ /** 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(); }
+
+ /// Empties the list of slots.
+ void clear();
+
+ /** Returns the number of slots in the list.
+ * @return The number of slots in the list.
+ */
+ size_type size() const noexcept;
+
+ /** Returns whether all slots in the list are blocked.
+ * @return @p true if all slots are blocked or the list is empty.
+ *
+ * @newin{2,4}
+ */
+ bool blocked() const noexcept;
+
+ /** Sets the blocking state of all slots in the list.
+ * If @e should_block is @p true then the blocking state is set.
+ * Subsequent emissions of the signal don't invoke the functors
+ * contained in the slots until block() with @e should_block = @p false is called.
+ * sigc::slot_base::block() and sigc::slot_base::unblock() can change the
+ * blocking state of individual slots.
+ * @param should_block Indicates whether the blocking state should be set or unset.
+ *
+ * @newin{2,4}
+ */
+ void block(bool should_block = true) noexcept;
+
+ /** Adds a slot at the bottom 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.
+ * @param slot_ The slot to add to the list of slots.
+ * @return An iterator pointing to the new slot in the list.
+ *
+ * @newin{2,8}
+ */
+ iterator_type connect(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.
+ * @return An iterator pointing to the new slot in the list.
+ */
+ iterator_type insert(iterator_type i, const 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.
+ * @return An iterator pointing to the new slot in the list.
+ *
+ * @newin{2,8}
+ */
+ 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();
+
+ /** 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
+ * because of some referred object being destroyed.
+ * It either calls slots_.erase() directly or defers the execution of
+ * erase() to sweep() when the signal is being emitted.
+ * @param d A local structure, created in insert().
+ */
+ static void* notify(void* d);
+
+ /** Reference counter.
+ * The object is destroyed when @em ref_count_ reaches zero.
+ */
+ short ref_count_;
+
+ /** Execution counter.
+ * Indicates whether the signal is being emitted.
+ */
+ short exec_count_;
+
+ /// Indicates whether the execution of sweep() is being deferred.
+ bool deferred_;
+
+ /// The list of slots.
+ std::list<slot_base> slots_;
+};
+
+/// Exception safe sweeper for cleaning up invalid slots on the slot list.
+struct SIGC_API signal_exec
+{
+ /// The parent sigc::signal_impl object.
+ signal_impl* sig_;
+
+ /** Increments the reference and 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<signal_impl*>(sig) )
+ { sig_->reference_exec(); }
+
+ /// Decrements the reference and execution counter of the parent sigc::signal_impl object.
+ inline ~signal_exec()
+ { sig_->unreference_exec(); }
+};
+
+/** 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
+{
+ 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)
+ {
+ 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;
+};
+
+} /* 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.
+ *
+ * @code
+ * signal_clicked.connect( sigc::mem_fun(*this, &MyWindow::on_clicked) );
+ * @endcode
+ *
+ * When the signal is emitted your method will be called.
+ *
+ * signal::connect() returns a connection, which you can later use to disconnect your method.
+ * 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.
+ * 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.
+ *
+ * @code
+ * class MyClass
+ * {
+ * public:
+ * typedef sigc::signal<void> MySignalType;
+ * MySignalType get_my_signal() { return m_my_signal; }
+ * private:
+ * MySignalType m_my_signal;
+ * };
+ * @endcode
+ *
+ * signal and slot objects provide the core functionality of this
+ * library. A slot is a container for an arbitrary functor.
+ * A signal is a list of slots that are executed on emission.
+ * For compile time type safety a list of template arguments
+ * must be provided for the signal template that determines the
+ * parameter list for emission. Functors and closures are converted
+ * into slots implicitly on connection, triggering compiler errors
+ * 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().
+ */
+
+/** 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
+ * 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
+ * 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.
+ *
+ * Deleting the signal during emission, e.g. from one of its slots, may result
+ * in memory leaks. This drawback is fixed in version 3 of libsigc++.
+ * A workaround is to make a copy of the signal during the emission:
+ * @code
+ * sigc::signal<...> sig2(*p_sig);
+ * p_sig->emit();
+ * @endcode
+ * This is not very costly. A sigc::signal<> is not much more than a pointer to
+ * a sigc::internal::signal_impl instance, which is not copied.
+ *
+ * @ingroup signal
+ */
+struct SIGC_API signal_base : public trackable
+{
+ typedef std::size_t size_type;
+
+ signal_base() noexcept;
+
+ signal_base(const signal_base& src) noexcept;
+
+ signal_base(signal_base&& src);
+
+ ~signal_base();
+
+ signal_base& operator=(const signal_base& src);
+
+ signal_base& operator=(signal_base&& src);
+
+ /** 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()); }
+
+ /// Empties the list of slots.
+ void clear();
+
+ /** Returns the number of slots in the list.
+ * @return The number of slots in the list.
+ */
+ size_type size() const noexcept;
+
+ /** Returns whether all slots in the list are blocked.
+ * @return @p true if all slots are blocked or the list is empty.
+ *
+ * @newin{2,4}
+ */
+ bool blocked() const noexcept;
+
+ /** Sets the blocking state of all slots in the list.
+ * If @e should_block is @p true then the blocking state is set.
+ * Subsequent emissions of the signal don't invoke the functors
+ * contained in the slots until unblock() or block() with
+ * @e should_block = @p false is called.
+ * sigc::slot_base::block() and sigc::slot_base::unblock() can change the
+ * blocking state of individual slots.
+ * @param should_block Indicates whether the blocking state should be set or unset.
+ *
+ * @newin{2,4}
+ */
+ void block(bool should_block = true) noexcept;
+
+ /** Unsets the blocking state of all slots in the list.
+ *
+ * @newin{2,4}
+ */
+ void unblock() noexcept;
+
+protected:
+ typedef internal::signal_impl::iterator_type iterator_type;
+
+ /** Adds a slot at the end of the list of slots.
+ * 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.
+ */
+ 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.
+ * 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{2,8}
+ */
+ iterator_type connect(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.
+ * @param slot_ The slot to add to the list of slots.
+ * @return An iterator pointing to the new slot in the list.
+ */
+ iterator_type insert(iterator_type i, const 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.
+ * @param slot_ The slot to add to the list of slots.
+ * @return An iterator pointing to the new slot in the list.
+ *
+ * @newin{2,8}
+ */
+ 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;
+
+ /// The signal_impl object encapsulating the slot list.
+ mutable internal::signal_impl* impl_;
+};
+
+} //namespace sigc
+
+#endif /* _SIGC_SIGNAL_BASE_H_ */
--- /dev/null
+/* 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, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef _SIGC_SLOT_H_
+#define _SIGC_SLOT_H_
+
+#include <sigc++/functors/slot.h>
+#endif /* _SIGC_SLOT_H_ */
--- /dev/null
+/*
+ * 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 <sigc++/trackable.h>
+
+namespace sigc
+{
+
+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)
+{}
+
+// Don't move the notification list.
+// The objects watching src don't need to be notified when the new object dies.
+// They need to be notified now, because src probably becomes useless.
+//
+// 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)
+{
+ src.notify_callbacks();
+}
+
+trackable& trackable::operator=(const trackable& src)
+{
+ if(this != &src)
+ notify_callbacks(); //Make sure that we have finished with existing stuff before replacing it.
+
+ return *this;
+}
+
+trackable& trackable::operator=(trackable&& src)
+{
+ if(this != &src)
+ {
+ notify_callbacks(); //Make sure that we have finished with existing stuff before replacing it.
+ src.notify_callbacks(); // src probably becomes useless.
+ }
+ return *this;
+}
+
+trackable::~trackable()
+{
+ notify_callbacks();
+}
+
+void trackable::add_destroy_notify_callback(void* data, func_destroy_notify func) const
+{
+ callback_list()->add_callback(data, func);
+}
+
+void trackable::remove_destroy_notify_callback(void* data) const
+{
+ callback_list()->remove_callback(data);
+}
+
+void trackable::notify_callbacks()
+{
+ if (callback_list_)
+ delete callback_list_; //This invokes all of the callbacks.
+
+ callback_list_ = nullptr;
+}
+
+internal::trackable_callback_list* trackable::callback_list() const
+{
+ if (!callback_list_)
+ callback_list_ = new internal::trackable_callback_list;
+
+ return callback_list_;
+}
+
+
+namespace internal
+{
+
+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)
+{
+ 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));
+}
+
+void trackable_callback_list::clear()
+{
+ clearing_ = true;
+
+ for (auto& callback : callbacks_)
+ if (callback.func_)
+ callback.func_(callback.data_);
+
+ callbacks_.clear();
+
+ clearing_ = false;
+}
+
+void trackable_callback_list::remove_callback(void* data)
+{
+ for (callback_list::iterator 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.
+ if (clearing_)
+ callback.func_ = nullptr;
+ else
+ callbacks_.erase(i);
+ return;
+ }
+ }
+}
+
+} /* namespace internal */
+
+} /* namespace sigc */
--- /dev/null
+/*
+ * 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
+ *
+ */
+#ifndef _SIGC_TRACKABLE_HPP_
+#define _SIGC_TRACKABLE_HPP_
+#include <list>
+#include <sigc++config.h>
+
+namespace sigc {
+
+namespace internal {
+
+typedef void* (*func_destroy_notify) (void* data);
+
+/** Destroy notification callback.
+ * A destroy notification callback consists of a data pointer and a
+ * function pointer. The function is executed from the owning callback
+ * list (of type sigc::internal::trackable_callback_list) when its parent
+ * object (of type sigc::trackable) is destroyed or overwritten.
+ */
+struct SIGC_API trackable_callback
+{
+ void* data_;
+ func_destroy_notify func_;
+ trackable_callback(void* data, func_destroy_notify func) noexcept
+ : data_(data), func_(func) {}
+};
+
+/** Callback list.
+ * A callback list holds an STL list of callbacks of type
+ * trackable_callback. Callbacks are added and removed with
+ * add_callback(), remove_callback() and clear(). The callbacks
+ * are invoked from clear() and from the destructor.
+ */
+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);
+
+ /** 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);
+
+ /** This invokes all of the callback functions.
+ */
+ void clear();
+
+ trackable_callback_list()
+ : clearing_(false) {}
+
+ trackable_callback_list(const trackable_callback_list& src) = delete;
+ trackable_callback_list& operator=(const trackable_callback_list& src) = delete;
+ trackable_callback_list(trackable_callback_list&& src) = delete;
+ trackable_callback_list& operator=(trackable_callback_list&& src) = delete;
+
+ /** This invokes all of the callback functions.
+ */
+ ~trackable_callback_list();
+
+private:
+ typedef std::list<trackable_callback> callback_list;
+ callback_list callbacks_;
+ bool clearing_;
+};
+
+} /* namespace internal */
+
+
+/** Base class for objects with auto-disconnection.
+ * trackable must be inherited when objects shall automatically
+ * invalidate slots referring to them on destruction.
+ * A slot built from a member function of a trackable derived
+ * type installs a callback that is invoked when the trackable object
+ * is destroyed or overwritten.
+ *
+ * add_destroy_notify_callback() and remove_destroy_notify_callback()
+ * can be used to manually install and remove callbacks when
+ * notification of the object dying is needed.
+ *
+ * notify_callbacks() invokes and removes all previously installed
+ * callbacks and can therefore be used to disconnect from all signals.
+ *
+ * Note that there is no virtual destructor. Don't use @p trackable*
+ * as pointer type for managing your data or the destructors of
+ * your derived types won't be called when deleting your objects.
+ *
+ * @ingroup signal
+ */
+struct SIGC_API trackable
+{
+ // Concerning noexcept specifications:
+ // libsigc++ does not have complete control of what happens when notify_callbacks()
+ // is called. It may throw an exception. A method that calls notify_callbacks()
+ // shall not be declared noexcept.
+
+ trackable() noexcept;
+
+ trackable(const trackable& src) noexcept;
+
+ trackable(trackable&& src);
+
+ trackable& operator=(const trackable& src);
+
+ trackable& operator=(trackable&& src);
+
+ ~trackable();
+
+ /*virtual ~trackable() {} */ /* we would need a virtual dtor for users
+ who insist on using "trackable*" as
+ pointer type for their own derived objects */
+
+ 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;
+
+ /** 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;
+
+ /// Execute and remove all previously installed callbacks.
+ void notify_callbacks();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+private:
+ /* The callbacks are held in a list of type trackable_callback_list.
+ * This list is allocated dynamically when the first callback is added.
+ */
+ internal::trackable_callback_list* callback_list() const;
+ mutable internal::trackable_callback_list* callback_list_;
+#endif
+};
+
+} /* namespace sigc */
+
+#endif /* _SIGC_TRACKABLE_HPP_ */
--- /dev/null
+/*
+ * 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
+ *
+ */
+#ifndef _SIGC_TYPE_TRAIT_H_
+#define _SIGC_TYPE_TRAIT_H_
+
+#include <sigc++config.h>
+
+
+namespace sigc {
+
+template <class T_type>
+struct type_trait
+{
+ typedef T_type& pass;
+ typedef const T_type& take;
+};
+
+template <class T_type, int N>
+struct type_trait<T_type[N]>
+{
+ typedef T_type*& pass;
+ typedef const T_type*& take;
+};
+
+template <class T_type>
+struct type_trait<T_type&>
+{
+ typedef T_type& pass;
+ typedef T_type& take;
+};
+
+template <class T_type>
+struct type_trait<const T_type&>
+{
+ typedef const T_type& pass;
+ typedef const T_type& take;
+};
+
+template<>
+struct type_trait<void>
+{
+ typedef void pass;
+ typedef void take;
+};
+
+template<typename T>
+using type_trait_pass_t = typename type_trait<T>::pass;
+
+template<typename T>
+using type_trait_take_t = typename type_trait<T>::take;
+
+} /* namespace sigc */
+
+#endif /* _SIGC_TYPE_TRAIT_H_ */
--- /dev/null
+/*
+ * 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
+ */
+#ifndef _SIGC_VISIT_EACH_HPP_
+#define _SIGC_VISIT_EACH_HPP_
+
+#include <sigc++/type_traits.h>
+#include <type_traits>
+
+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 <bool I_derived, class T_type, class T_limit>
+struct with_type;
+
+//Specialization for I_derived = false
+template <class T_type, class T_limit> struct
+with_type<false, T_type, T_limit>
+{
+ static void execute_(const T_type&, const T_limit&) {}
+};
+
+//Specialization for I_derived = true
+template <class T_type, class T_limit>
+struct with_type<true, T_type, T_limit>
+{
+ 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 <class T_target, class T_action>
+struct limit_derived_target
+{
+ typedef limit_derived_target<T_target, T_action> T_self;
+
+ template <class T_type>
+ void operator()(const T_type& _A_type) const
+ {
+ with_type<std::is_base_of<T_target, T_type>::value || std::is_same<T_target, T_type>::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.
+
+template <bool I_derived, class T_type, class T_limit>
+struct with_type_pointer;
+
+//Specialization for I_derived = false
+template <class T_type, class T_limit>
+struct with_type_pointer<false, T_type, T_limit>
+{
+ static void execute_(const T_type&, const T_limit&) {}
+};
+
+//Specialization for I_derived = true
+template <class T_type, class T_limit>
+struct with_type_pointer<true, T_type, T_limit>
+{
+ static void execute_(const T_type& _A_type, const T_limit& _A_action)
+ { _A_action.action_(&_A_type); }
+};
+
+template <class T_target, class T_action>
+struct limit_derived_target<T_target*, T_action>
+{
+ typedef limit_derived_target<T_target*, T_action> T_self;
+
+ template <class T_type>
+ void operator()(const T_type& _A_type) const
+ {
+ with_type_pointer<std::is_base_of<T_target, T_type>::value || std::is_same<T_target, T_type>::value, T_type, T_self>::execute_(_A_type, *this);
+ }
+
+ limit_derived_target(const T_action& _A_action)
+ : action_(_A_action)
+ {}
+
+ T_action action_;
+};
+
+} /* namespace internal */
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+// struct visitor was introduced as a result of https://bugzilla.gnome.org/show_bug.cgi?id=724496
+// The advantage of using specializations of a template struct instead of overloads of
+// a template function is described by Herb Sutter in http://www.gotw.ca/publications/mill17.htm
+// In libsigc++ the main reason for using this technique is that we can avoid using ADL
+// (argument-dependent lookup), and therefore there is no risk that a visit_each() overload
+// in e.g. Boost is selected by mistake.
+
+/** sigc::visitor<T_functor>::do_visit_each() performs a functor on each of the targets of a functor.
+ * All unknown types just call @a _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.
+ *
+ * @par Example:
+ * @code
+ * namespace some_ns
+ * {
+ * struct some_functor
+ * {
+ * void operator()() {}
+ * some_possibly_sigc_trackable_derived_type some_data_member;
+ * some_other_functor_type some_other_functor;
+ * };
+ * }
+ *
+ * namespace sigc
+ * {
+ * template <>
+ * struct visitor<some_ns::some_functor>
+ * {
+ * template <class T_action>
+ * static void do_visit_each(const T_action& _A_action,
+ * const some_ns::some_functor& _A_target)
+ * {
+ * sigc::visit_each(_A_action, _A_target.some_data_member);
+ * sigc::visit_each(_A_action, _A_target.some_other_functor);
+ * }
+ * };
+ * }
+ * @endcode
+ *
+ * @ingroup sigcfunctors
+ */
+template <class T_functor>
+struct visitor
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action, const T_functor& _A_functor)
+ {
+ _A_action(_A_functor);
+ }
+};
+
+/** This function performs a functor on each of the targets of a functor.
+ *
+ * @ingroup sigcfunctors
+ */
+template <class T_action, class T_functor>
+void visit_each(const T_action& _A_action, const T_functor& _A_functor)
+{ sigc::visitor<T_functor>::do_visit_each(_A_action, _A_functor); }
+
+/** This function performs a functor on each of the targets
+ * of a functor limited to a restricted type.
+ *
+ * @ingroup sigcfunctors
+ */
+template <class T_type, class T_action, class T_functor>
+void visit_each_type(const T_action& _A_action, const T_functor& _A_functor)
+{
+ typedef internal::limit_derived_target<T_type, T_action> 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 std::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 std::ref() therefore does not work on those platforms. murrayc
+ // sigc::visit_each<type_limited_action, T_functor>(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.
+
+ sigc::visit_each(limited_action, _A_functor);
+}
+
+} /* namespace sigc */
+#endif
--- /dev/null
+
+/* Define to omit deprecated API from the library. */
+#undef SIGCXX_DISABLE_DEPRECATED
+
+/* Major version number of sigc++. */
+#undef SIGCXX_MAJOR_VERSION
+
+/* Micro version number of sigc++. */
+#undef SIGCXX_MICRO_VERSION
+
+/* Minor version number of sigc++. */
+#undef SIGCXX_MINOR_VERSION
+
+/* 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
+#else /* !_WIN32 */
+# define SIGC_CONFIGURE 1
+#endif /* !_WIN32 */
+
+#ifdef SIGC_MSC
+/*
+ * MS VC7 Warning 4251 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)
+
+# 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
+
+#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
+#else /* !SIGC_DLL */
+# define SIGC_API
+#endif /* !SIGC_DLL */
--- /dev/null
+/* 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
+# 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
+#else /* !_WIN32 */
+# define SIGC_CONFIGURE 1
+#endif /* !_WIN32 */
+
+#ifdef SIGC_MSC
+/*
+ * MS VC7 Warning 4251 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)
+
+# 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
+
+#else /* SIGC_MSC */
+
+/* does the C++ compiler support the use of a particular specialization when
+ calling operator() template methods. */
+#mesondefine SIGC_GCC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+/* Define if the non-standard Sun reverse_iterator must be used. */
+#mesondefine 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. */
+#mesondefine SIGC_MSVC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+/* does the C++ preprocessor support pragma push_macro() and pop_macro(). */
+#mesondefine 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
+#else /* !SIGC_DLL */
+# define SIGC_API
+#endif /* !SIGC_DLL */
+
+#endif /* !SIGCXXCONFIG_H_INCLUDED */
--- /dev/null
+[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
--- /dev/null
+## Copyright (c) 2009 Openismus GmbH <http://www.openismus.com/>
+##
+## This file is part of libsigc++.
+##
+## libsigc++ 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.
+##
+## libsigc++ 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 <http://www.gnu.org/licenses/>.
+
+AM_CPPFLAGS = -I$(top_builddir) -I$(top_srcdir)
+AM_CXXFLAGS = $(SIGC_WXXFLAGS)
+
+sigc_libs = $(top_builddir)/sigc++/libsigc-$(SIGCXX_API_VERSION).la
+LDADD = $(sigc_libs)
+
+check_PROGRAMS = \
+ test_accum_iter \
+ test_accumulated \
+ test_bind \
+ test_bind_as_slot \
+ test_bind_ref \
+ test_bind_refptr \
+ test_bind_return \
+ test_compose \
+ 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_mem_fun \
+ test_ptr_fun \
+ test_retype \
+ test_retype_return \
+ test_signal \
+ test_signal_move \
+ test_size \
+ test_slot \
+ test_slot_disconnect \
+ test_slot_move \
+ test_trackable \
+ test_trackable_move \
+ test_track_obj \
+ test_visit_each
+
+TESTS = $(check_PROGRAMS)
+
+sigc_test_util = testutilities.h testutilities.cc
+
+test_accum_iter_SOURCES = test_accum_iter.cc $(sigc_test_util)
+test_accumulated_SOURCES = test_accumulated.cc $(sigc_test_util)
+test_bind_SOURCES = test_bind.cc $(sigc_test_util)
+test_bind_as_slot_SOURCES = test_bind_as_slot.cc $(sigc_test_util)
+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_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_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_signal_SOURCES = test_signal.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)
+test_slot_disconnect_SOURCES = test_slot_disconnect.cc $(sigc_test_util)
+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_visit_each_SOURCES = test_visit_each.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
--- /dev/null
+/* Copyright 2003 - 2016, The libsigc++ Development Team
+ * Assigned to public domain. Use as you wish without restriction.
+ */
+
+#include <iostream>
+#include <sigc++/signal.h>
+#include <sigc++/functors/mem_fun.h>
+#include <boost/timer/timer.hpp>
+
+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;
+ sigc::signal<int(int)>::iterator it;
+
+ // slot benchmark ...
+
+ sigc::slot<int(int)> 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<int(int)> 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<int(int)> 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<int(int)> 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<int(int)> emitter;
+ sigc::signal<int(int)>::iterator it;
+
+ std::cout << "elapsed time for " << COUNT << " connections/disconnections:" << std::endl;
+ boost::timer::auto_cpu_timer timer;
+
+ for (int i=0; i < COUNT; ++i)
+ {
+ it = emitter.connect(mem_fun(foobar1, &foo::bar));
+ it->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();
+}
--- /dev/null
+# tests
+
+# input: sigcxx_own_dep, 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_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_deduce_result_type', ['test_deduce_result_type.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_functor_trait', ['test_functor_trait.cc', 'testutilities.cc']],
+ [[], 'test_hide', ['test_hide.cc', 'testutilities.cc']],
+ [[], 'test_limit_reference', ['test_limit_reference.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_signal', ['test_signal.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_visit_each', ['test_visit_each.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: true
+ )
+
+ test(ex_name, exe_file)
+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
+ )
+
+ if do_benchmark
+ test(ex_name, exe_file,
+ timeout: benchmark_timeout,
+ )
+ endif
+ endforeach
+endif
--- /dev/null
+#include "testutilities.h"
+#include <sigc++/sigc++.h>
+#include <sstream>
+#include <algorithm>
+#include <functional>
+#include <cstdlib>
+
+namespace
+{
+std::ostringstream result_stream;
+
+int ident(int i)
+{
+ return i;
+}
+
+template<typename T>
+struct min_accum
+{
+ typedef T result_type;
+
+ template<class I>
+#ifndef SIGC_HAVE_SUN_REVERSE_ITERATOR
+ typename std::iterator_traits<I>::value_type operator()(I i1, I i2)
+#else
+ typename I::value_type operator()(I i1, I i2)
+#endif
+ {
+ return *std::min_element(i1, i2);
+ }
+};
+
+} // 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::signal0<int,min_accum<int> > signal;
+
+ signal.connect(sigc::bind(sigc::ptr_fun(ident), 3));
+ signal.connect(sigc::bind(sigc::ptr_fun(ident), 1));
+ signal.connect(sigc::bind(sigc::ptr_fun(ident), 42));
+
+ result_stream << signal();
+ util->check_result(result_stream, "1");
+
+ return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
--- /dev/null
+// -*- c++ -*-
+/* Copyright 2002, The libsigc++ Development Team
+ * Assigned to public domain. Use as you wish without restriction.
+ */
+
+#include "testutilities.h"
+#include <sigc++/trackable.h>
+#include <sigc++/signal.h>
+#include <sigc++/functors/ptr_fun.h>
+#include <sigc++/functors/mem_fun.h>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <cstdlib>
+
+namespace
+{
+
+TestUtilities* util = nullptr;
+std::ostringstream result_stream;
+
+struct arithmetic_mean_accumulator
+{
+ typedef double result_type;
+ template<typename T_iterator>
+ double operator()(T_iterator first, T_iterator last) const
+ {
+ double value_ = 0;
+ int n_ = 0;
+ for (; first != last; ++first, ++n_)
+ value_ += *first;
+ return (n_ ? value_ / n_ : -1); // empty slot list <=> n_==0
+ }
+};
+
+template<class Ret>
+struct vector_accumulator
+{
+ typedef std::vector<Ret> result_type;
+ template<typename T_iterator>
+ result_type operator()(T_iterator first, T_iterator last) const
+ {
+ result_type vec;
+ for (; first != last; ++first)
+ vec.push_back(*first);
+ return vec;
+ }
+};
+
+int foo(int i)
+{
+ const int result = 3 * i + 1;
+ result_stream << "foo: " << result << ", ";
+ return result;
+}
+
+int bar(double i)
+{
+ const int result = 5 * int(i) - 3;
+ result_stream << "bar: " << result << ", ";
+ return result;
+}
+
+struct A : public sigc::trackable
+{
+ int foo(int i)
+ {
+ const int result = 20 * i - 14;
+ result_stream << "A::foo: " << result << ", ";
+ return result;
+ }
+};
+
+void test_empty_signal()
+{
+ sigc::signal<int,int>::accumulated<arithmetic_mean_accumulator> sig;
+ sigc::signal<int,int>::accumulated<vector_accumulator<int> > 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");
+}
+
+void test_mean()
+{
+ sigc::signal<int,int>::accumulated<arithmetic_mean_accumulator> sig;
+
+ A a;
+ sig.connect(sigc::ptr_fun1(&foo));
+ sig.connect(sigc::mem_fun1(a, &A::foo));
+ sig.connect(sigc::ptr_fun1(&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");
+
+ 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");
+}
+
+void test_vector_accumulator()
+{
+ sigc::signal<int,int>::accumulated<vector_accumulator<int> > 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 ");
+
+ 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 ");
+}
+
+} // 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_vector_accumulator();
+
+ return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
--- /dev/null
+// -*- c++ -*-
+/* Copyright 2002, The libsigc++ Development Team
+ * Assigned to public domain. Use as you wish without restriction.
+ */
+
+#include "testutilities.h"
+#include <sigc++/adaptors/bind.h>
+#include <sigc++/functors/slot.h>
+#include <sstream>
+#include <string>
+#include <cstdlib>
+
+namespace
+{
+std::ostringstream result_stream;
+
+struct foo : public sigc::functor_base
+{
+ // 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;
+ }
+
+ int operator()(int i, int j)
+ {
+ result_stream << "foo(int " << i << ", int "<< j << ") ";
+ return i + j;
+ }
+
+ int operator()(int i, int j, int k)
+ {
+ result_stream << "foo(int " << i << ", int " << j << ", int " << k << ") ";
+ return 0;
+ }
+};
+
+struct foo_void : public sigc::functor_base
+{
+ typedef void result_type;
+
+ void operator()(int i)
+ {
+ result_stream << "foo_void(int " << i << ")";
+ }
+};
+
+int bar(int i, int j)
+{
+ result_stream << "bar(int " << i << ", int " << j << ") ";
+ return i + j;
+}
+
+bool simple(bool test)
+{
+ result_stream << "simple(bool " << test << ") ";
+ return test;
+}
+
+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) {}
+
+ //non-copyable:
+ book(const book&) = delete;
+ book& operator=(const book&) = delete;
+
+ //non movable:
+ book(book&&) = delete;
+ book& operator=(book&&) = delete;
+
+ std::string& get_name() { return name_; }
+ operator std::string& () { return get_name(); }
+
+private:
+ std::string name_;
+};
+
+} // 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;
+
+ // replacing bind1st, bind2nd
+ result_stream << sigc::bind<0>(foo(), -12345)(5);
+ util->check_result(result_stream, "foo(int -12345, int 5) -12340");
+
+ result_stream << sigc::bind<1>(foo(), -12345)(5);
+ util->check_result(result_stream, "foo(int 5, int -12345) -12340");
+
+ // multiple
+ sigc::bind(foo(), 1, 2)();
+ util->check_result(result_stream, "foo(int 1, int 2) ");
+
+ // bind from end
+ sigc::bind<-1>(foo(), 4)(3);
+ util->check_result(result_stream, "foo(int 3, int 4) ");
+
+ sigc::bind(foo(), 4)(3);
+ util->check_result(result_stream, "foo(int 3, int 4) ");
+
+ // used together
+ sigc::bind<0>(sigc::bind<0>(foo(), 7), 8)();
+ util->check_result(result_stream, "foo(int 7, int 8) ");
+
+ // void return
+ sigc::bind(foo(), 9, 10)(11); // (only returned void if typeof() would be supported)
+ util->check_result(result_stream, "foo(int 11, int 9, int 10) ");
+
+ sigc::bind(foo_void(), 12)();
+ util->check_result(result_stream, "foo_void(int 12)");
+
+ // function pointer instead of functor
+ sigc::bind(&bar, 13, 14)();
+ util->check_result(result_stream, "bar(int 13, int 14) ");
+
+ // method pointer instead of functor
+ book test_book("otto");
+ 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
+ result_stream << sigc::bind(foo(), 15)();
+ util->check_result(result_stream, "foo(int 15) 1");
+
+ result_stream << sigc::bind(&simple, true)();
+ util->check_result(result_stream, "simple(bool 1) 1");
+
+ // test references
+ std::string str("guest book");
+ 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<void> sl;
+ {
+ book guest_book("karl");
+ sl = sigc::bind(&egon, std::ref(guest_book));
+ sl();
+ result_stream << " " << static_cast<std::string&>(guest_book);
+ util->check_result(result_stream, "egon(string 'karl') 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;
+}
--- /dev/null
+// -*- c++ -*-
+/* Copyright 2002, The libsigc++ Development Team
+ * Assigned to public domain. Use as you wish without restriction.
+ */
+
+#include "testutilities.h"
+#include <sigc++/adaptors/bind.h>
+#include <sigc++/functors/slot.h>
+#include <sstream>
+#include <string>
+#include <functional> //For std::ref().
+#include <cstdlib>
+
+namespace
+{
+
+std::ostringstream result_stream;
+
+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)
+{
+ 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)
+{
+ result_stream << "func_to_bind_with_const_iter(" << a << ", " << *b << ")";
+ return true;
+}
+
+} // 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;
+
+
+ //Test that sigc::bind()'s result can be converted to a sigc::slot<>.
+ {
+ sigc::slot<bool, int> 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:
+ {
+ std::string c = "2";
+ sigc::slot<bool, int> 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:
+ {
+ const std::string c = "2";
+ sigc::slot<bool, int> 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)");
+ }
+
+ return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
--- /dev/null
+#include "testutilities.h"
+#include <sigc++/sigc++.h>
+#include <sstream>
+#include <string>
+#include <cstdlib>
+
+namespace
+{
+std::ostringstream result_stream;
+
+class Param : public sigc::trackable
+{
+public:
+ Param(const std::string& name)
+ : name_(name)
+ {}
+
+ //non-copyable,
+ //so it can only be used with sigc::bind() via std::ref()
+ Param(const Param&) = delete;
+ Param& operator=(const Param&) = delete;
+
+ //non movable:
+ Param(Param&&) = delete;
+ Param& operator=(Param&&) = delete;
+
+ std::string name_;
+};
+
+void handler(Param& param)
+{
+ result_stream << " handler(param): param.name_=" << param.name_;
+}
+
+} // 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;
+
+ auto slot_full = sigc::ptr_fun(&handler);
+ sigc::slot<void> slot_bound;
+
+ slot_bound();
+ util->check_result(result_stream, "");
+
+ {
+ //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, std::ref(param));
+ slot_bound = sigc::bind< -1, std::reference_wrapper<Param> >(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");
+ } // 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;
+}
--- /dev/null
+// Bug 564005 - Valgrind errors and crash on exit with Gtk::UIManager
+// Bug 154498 - Unnecessary warning on console: signalproxy_connectionnode.cc
+
+// libsigc++-only test case. (Or almost so. RefPtr is stolen from glibmm.)
+
+// This test case is much more useful if it's run under valgrind.
+
+#include "testutilities.h"
+#include <sigc++/sigc++.h>
+#include <sstream>
+#include <cstdlib>
+
+#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 <glibmmconfig.h>
+
+namespace Glib
+{
+
+/** RefPtr<> is a reference-counting shared smartpointer.
+ *
+ * Some objects in gtkmm are obtained from a shared
+ * store. Consequently you cannot instantiate them yourself. Instead they
+ * return a RefPtr which behaves much like an ordinary pointer in that members
+ * can be reached with the usual <code>object_ptr->member</code> notation.
+ * Unlike most other smart pointers, RefPtr doesn't support dereferencing
+ * through <code>*object_ptr</code>.
+ *
+ * Reference counting means that a shared reference count is incremented each
+ * time a RefPtr is copied, and decremented each time a RefPtr is destroyed,
+ * for instance when it leaves its scope. When the reference count reaches
+ * zero, the contained object is deleted, meaning you don't need to remember
+ * to delete the object.
+ *
+ * RefPtr<> can store any class that has reference() and unreference() methods.
+ * In gtkmm, that is anything derived from Glib::ObjectBase, such as
+ * Gdk::Pixmap.
+ *
+ * See the "Memory Management" section in the "Programming with gtkmm"
+ * book for further information.
+ */
+template <class T_CppObject>
+class RefPtr
+{
+public:
+ /** Default constructor
+ *
+ * Afterwards it will be null and use of -> will cause a segmentation fault.
+ */
+ inline RefPtr();
+
+ /// Destructor - decrements reference count.
+ inline ~RefPtr();
+
+ /// For use only by the ::create() methods.
+ explicit inline RefPtr(T_CppObject* pCppObject);
+
+ /** Copy constructor
+ *
+ * This increments the shared reference count.
+ */
+ inline RefPtr(const RefPtr<T_CppObject>& src);
+
+ /** Copy constructor (from different, but castable type).
+ *
+ * Increments the reference count.
+ */
+ template <class T_CastFrom>
+ inline RefPtr(const RefPtr<T_CastFrom>& src);
+
+ /** Swap the contents of two RefPtr<>.
+ * This method swaps the internal pointers to T_CppObject. This can be
+ * done safely without involving a reference/unreference cycle and is
+ * therefore highly efficient.
+ */
+ inline void swap(RefPtr<T_CppObject>& other);
+
+ /// Copy from another RefPtr:
+ inline RefPtr<T_CppObject>& operator=(const RefPtr<T_CppObject>& src);
+
+ /** Copy from different, but castable type).
+ *
+ * Increments the reference count.
+ */
+ template <class T_CastFrom>
+ inline RefPtr<T_CppObject>& operator=(const RefPtr<T_CastFrom>& src);
+
+ /// Tests whether the RefPtr<> point to the same underlying instance.
+ inline bool operator==(const RefPtr<T_CppObject>& src) const;
+
+ /// See operator==().
+ inline bool operator!=(const RefPtr<T_CppObject>& src) const;
+
+ /** Dereferencing.
+ *
+ * Use the methods of the underlying instance like so:
+ * <code>refptr->memberfun()</code>.
+ */
+ inline T_CppObject* operator->() const;
+
+ /** Test whether the RefPtr<> points to any underlying instance.
+ *
+ * Mimics usage of ordinary pointers:
+ * @code
+ * if (ptr)
+ * do_something();
+ * @endcode
+ */
+ 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().
+ inline void clear();
+#endif //GLIBMM_DISABLE_DEPRECATED
+
+ /** Set underlying instance to 0, decrementing reference count of existing instance appropriately.
+ * @newin{2,16}
+ */
+ inline void reset();
+
+ /** Dynamic cast to derived class.
+ *
+ * The RefPtr can't be cast with the usual notation so instead you can use
+ * @code
+ * ptr_derived = RefPtr<Derived>::cast_dynamic(ptr_base);
+ * @endcode
+ */
+ template <class T_CastFrom>
+ static inline RefPtr<T_CppObject> cast_dynamic(const RefPtr<T_CastFrom>& src);
+
+ /** Static cast to derived class.
+ *
+ * Like the dynamic cast; the notation is
+ * @code
+ * ptr_derived = RefPtr<Derived>::cast_static(ptr_base);
+ * @endcode
+ */
+ template <class T_CastFrom>
+ static inline RefPtr<T_CppObject> cast_static(const RefPtr<T_CastFrom>& src);
+
+ /** Cast to non-const.
+ *
+ * The RefPtr can't be cast with the usual notation so instead you can use
+ * @code
+ * ptr_unconst = RefPtr<UnConstType>::cast_const(ptr_const);
+ * @endcode
+ */
+ template <class T_CastFrom>
+ static inline RefPtr<T_CppObject> cast_const(const RefPtr<T_CastFrom>& src);
+
+ /** Compare based on the underlying instance address.
+ *
+ * This is needed in code that requires an ordering on
+ * RefPtr<T_CppObject> instances, e.g. std::set<RefPtr<T_CppObject> >.
+ *
+ * Without these, comparing two RefPtr<T_CppObject> instances
+ * is still syntactically possible, but the result is semantically
+ * wrong, as p1 REL_OP p2 is interpreted as (bool)p1 REL_OP (bool)p2.
+ */
+ inline bool operator<(const RefPtr<T_CppObject>& src) const;
+
+ /// See operator<().
+ inline bool operator<=(const RefPtr<T_CppObject>& src) const;
+
+ /// See operator<().
+ inline bool operator>(const RefPtr<T_CppObject>& src) const;
+
+ /// See operator<().
+ inline bool operator>=(const RefPtr<T_CppObject>& src) const;
+
+private:
+ 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 <class T_CppObject> inline
+T_CppObject* RefPtr<T_CppObject>::operator->() const
+{
+ return pCppObject_;
+}
+
+template <class T_CppObject> inline
+RefPtr<T_CppObject>::RefPtr()
+:
+ pCppObject_ (nullptr)
+{}
+
+template <class T_CppObject> inline
+RefPtr<T_CppObject>::~RefPtr()
+{
+ if(pCppObject_)
+ pCppObject_->unreference(); // This could cause pCppObject to be deleted.
+}
+
+template <class T_CppObject> inline
+RefPtr<T_CppObject>::RefPtr(T_CppObject* pCppObject)
+:
+ pCppObject_ (pCppObject)
+{}
+
+template <class T_CppObject> inline
+RefPtr<T_CppObject>::RefPtr(const RefPtr<T_CppObject>& src)
+:
+ pCppObject_ (src.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 <class T_CppObject>
+ template <class T_CastFrom>
+inline
+RefPtr<T_CppObject>::RefPtr(const RefPtr<T_CastFrom>& 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->())
+{
+ if(pCppObject_)
+ pCppObject_->reference();
+}
+
+template <class T_CppObject> inline
+void RefPtr<T_CppObject>::swap(RefPtr<T_CppObject>& other)
+{
+ const auto temp = pCppObject_;
+ pCppObject_ = other.pCppObject_;
+ other.pCppObject_ = temp;
+}
+
+template <class T_CppObject> inline
+RefPtr<T_CppObject>& RefPtr<T_CppObject>::operator=(const RefPtr<T_CppObject>& src)
+{
+ // In case you haven't seen the swap() technique to implement copy
+ // assignment before, here's what it does:
+ //
+ // 1) Create a temporary RefPtr<> instance via the copy ctor, thereby
+ // increasing the reference count of the source object.
+ //
+ // 2) Swap the internal object pointers of *this and the temporary
+ // RefPtr<>. After this step, *this already contains the new pointer,
+ // and the old pointer is now managed by temp.
+ //
+ // 3) The destructor of temp is executed, thereby unreferencing the
+ // old object pointer.
+ //
+ // This technique is described in Herb Sutter's "Exceptional C++", and
+ // has a number of advantages over conventional approaches:
+ //
+ // - Code reuse by calling the copy ctor.
+ // - Strong exception safety for free.
+ // - Self assignment is handled implicitely.
+ // - Simplicity.
+ // - It just works and is hard to get wrong; i.e. you can use it without
+ // even thinking about it to implement copy assignment whereever the
+ // object data is managed indirectly via a pointer, which is very common.
+
+ RefPtr<T_CppObject> temp (src);
+ this->swap(temp);
+ return *this;
+}
+
+template <class T_CppObject>
+ template <class T_CastFrom>
+inline
+RefPtr<T_CppObject>& RefPtr<T_CppObject>::operator=(const RefPtr<T_CastFrom>& src)
+{
+ RefPtr<T_CppObject> temp (src);
+ this->swap(temp);
+ return *this;
+}
+
+template <class T_CppObject> inline
+bool RefPtr<T_CppObject>::operator==(const RefPtr<T_CppObject>& src) const
+{
+ return (pCppObject_ == src.pCppObject_);
+}
+
+template <class T_CppObject> inline
+bool RefPtr<T_CppObject>::operator!=(const RefPtr<T_CppObject>& src) const
+{
+ return (pCppObject_ != src.pCppObject_);
+}
+
+template <class T_CppObject> inline
+RefPtr<T_CppObject>::operator bool() const
+{
+ return (pCppObject_ != nullptr);
+}
+
+#ifndef GLIBMM_DISABLE_DEPRECATED
+template <class T_CppObject> inline
+void RefPtr<T_CppObject>::clear()
+{
+ reset();
+}
+#endif //GLIBMM_DISABLE_DEPRECATED
+
+template <class T_CppObject> inline
+void RefPtr<T_CppObject>::reset()
+{
+ RefPtr<T_CppObject> temp; // swap with an empty RefPtr<> to clear *this
+ this->swap(temp);
+}
+
+template <class T_CppObject>
+ template <class T_CastFrom>
+inline
+RefPtr<T_CppObject> RefPtr<T_CppObject>::cast_dynamic(const RefPtr<T_CastFrom>& src)
+{
+ const auto pCppObject = dynamic_cast<T_CppObject*>(src.operator->());
+
+ if(pCppObject)
+ pCppObject->reference();
+
+ return RefPtr<T_CppObject>(pCppObject);
+}
+
+template <class T_CppObject>
+ template <class T_CastFrom>
+inline
+RefPtr<T_CppObject> RefPtr<T_CppObject>::cast_static(const RefPtr<T_CastFrom>& src)
+{
+ const auto pCppObject = static_cast<T_CppObject*>(src.operator->());
+
+ if(pCppObject)
+ pCppObject->reference();
+
+ return RefPtr<T_CppObject>(pCppObject);
+}
+
+template <class T_CppObject>
+ template <class T_CastFrom>
+inline
+RefPtr<T_CppObject> RefPtr<T_CppObject>::cast_const(const RefPtr<T_CastFrom>& src)
+{
+ const auto pCppObject = const_cast<T_CppObject*>(src.operator->());
+
+ if(pCppObject)
+ pCppObject->reference();
+
+ return RefPtr<T_CppObject>(pCppObject);
+}
+
+template <class T_CppObject> inline
+bool RefPtr<T_CppObject>::operator<(const RefPtr<T_CppObject>& src) const
+{
+ return (pCppObject_ < src.pCppObject_);
+}
+
+template <class T_CppObject> inline
+bool RefPtr<T_CppObject>::operator<=(const RefPtr<T_CppObject>& src) const
+{
+ return (pCppObject_ <= src.pCppObject_);
+}
+
+template <class T_CppObject> inline
+bool RefPtr<T_CppObject>::operator>(const RefPtr<T_CppObject>& src) const
+{
+ return (pCppObject_ > src.pCppObject_);
+}
+
+template <class T_CppObject> inline
+bool RefPtr<T_CppObject>::operator>=(const RefPtr<T_CppObject>& src) const
+{
+ return (pCppObject_ >= src.pCppObject_);
+}
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+/** @relates Glib::RefPtr */
+template <class T_CppObject> inline
+void swap(RefPtr<T_CppObject>& lhs, RefPtr<T_CppObject>& rhs)
+{
+ lhs.swap(rhs);
+}
+
+} // namespace Glib
+
+
+#endif /* _GLIBMM_REFPTR_H */
+
+
+namespace
+{
+std::ostringstream result_stream;
+
+class Action : public sigc::trackable
+{
+public:
+ Action() : ref_count(1) { }
+
+ void reference() { ++ref_count; }
+ void unreference() { if (--ref_count <= 0) delete this; }
+
+ void emit_sig1(int n) { sig1.emit(n); }
+
+ sigc::signal<void, int>& signal_sig1() { return sig1; }
+
+private:
+ sigc::signal<void, int> sig1;
+ int ref_count;
+
+};
+
+class Test : public sigc::trackable
+{
+public:
+ 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));
+#else
+ Glib::RefPtr<Action> action2(new Action);
+ action->signal_sig1().connect(sigc::bind(sigc::mem_fun(*this, &Test::on_sig1), action2));
+#endif
+ }
+
+ ~Test()
+ {
+ result_stream << "delete Test; ";
+ }
+
+ void on_sig1(int n, Glib::RefPtr<Action> /* action */)
+ {
+ result_stream << "Test::on_sig1, n=" << n << "; ";
+ }
+
+ Glib::RefPtr<Action> action;
+
+}; // end Test
+
+} // 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;
+
+ auto test = new Test;
+
+ test->action->emit_sig1(23);
+ delete test;
+ util->check_result(result_stream, "new Test; Test::on_sig1, n=23; delete Test; ");
+
+ return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
--- /dev/null
+// -*- c++ -*-
+/* Copyright 2002, The libsigc++ Development Team
+ * Assigned to public domain. Use as you wish without restriction.
+ */
+
+#include "testutilities.h"
+#include <sigc++/adaptors/bind_return.h>
+#include <sigc++/functors/slot.h>
+#include <sstream>
+#include <string>
+#include <cstdlib>
+
+namespace
+{
+std::ostringstream result_stream;
+
+struct foo
+{
+ void operator()(int i)
+ {
+ result_stream << "foo(int " << i << ") ";
+ }
+
+ float operator()(float i)
+ {
+ result_stream << "foo(float " << i << ") ";
+ return i*5;
+ }
+};
+
+struct bar : public sigc::trackable
+{
+ bar(int i = 0) : i_(i) {}
+ operator int() { return i_; }
+ int i_;
+};
+
+} // 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;
+
+ result_stream << sigc::bind_return(foo(), -12345)(5);
+ util->check_result(result_stream, "foo(int 5) -12345");
+
+ // Here we just build a functor, not a slot. There is no such thing as a
+ // default functor, or an invalidated functor. As such, functors can return
+ // references.
+ std::string str("guest book");
+ // A convoluted way to do
+ // sigc::bind_return(foo(), std::ref(str))(6) = "main";
+ sigc::bind_return<std::reference_wrapper<std::string> >(foo(), std::ref(str))(6) = "main";
+ result_stream << str;
+ util->check_result(result_stream, "foo(int 6) main");
+
+ // Here we build a slot (constructed from a functor). Slots cannot return
+ // references: if they could, then what would be the return value of the
+ // default slot or of an invalidated slot? On the other hand, slots are
+ // guaranteed to be able to construct and return a valid default instance as
+ // long as there exists a default constructor for it.
+ //
+ // Therefore, we use 'bar', and not 'bar&' for this slot signature.
+ sigc::slot<bar, int> sl;
+ {
+ bar choco(-1);
+ sl = sigc::bind_return(foo(),std::ref(choco));
+ result_stream << sl(7);
+ util->check_result(result_stream, "foo(int 7) -1");
+ } // auto-disconnect
+
+ result_stream << sl(8);
+ util->check_result(result_stream, "0");
+
+ return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
--- /dev/null
+// -*- c++ -*-
+/* Copyright 2002, The libsigc++ Development Team
+ * Assigned to public domain. Use as you wish without restriction.
+ */
+
+#include "testutilities.h"
+#include <sigc++/adaptors/compose.h>
+#include <sstream>
+#include <cstdlib>
+
+// assume existance of T_functor::result_type for unknown functor types:
+namespace sigc { SIGC_FUNCTORS_HAVE_RESULT_TYPE }
+
+namespace
+{
+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;
+ }
+
+ double operator()(double i)
+ {
+ result_stream << "set(double " << i << ") ";
+ return i*5;
+ }
+};
+
+struct set_void
+{
+ typedef void result_type;
+
+ 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;
+ }
+
+ double 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);
+ }
+#endif
+};
+
+} // 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;
+
+ result_stream << sigc::compose(set(), get())();
+ util->check_result(result_stream, "get() set(double 1) 5");
+
+ result_stream << sigc::compose(set(), get())(1);
+ util->check_result(result_stream, "get(1) set(double 2) 10");
+
+ 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
+ util->check_result(result_stream, "get(3) set_void(double 6)");
+
+ return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
--- /dev/null
+#include "testutilities.h"
+#include <sstream>
+#include <cstdlib>
+#include <sigc++/sigc++.h>
+#include <stdlib.h>
+#include <string.h>
+
+namespace
+{
+std::ostringstream result_stream;
+
+void Foo(sigc::trackable&)
+{
+ result_stream << "Foo(x)";
+}
+
+} // 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;
+
+ std::ostringstream pointer_stream;
+ auto t = new sigc::trackable();
+ pointer_stream << t;
+ result_stream << "sigc::trackable instance at " << pointer_stream.str();
+ util->check_result(result_stream, "sigc::trackable instance at " + pointer_stream.str());
+ pointer_stream.str("");
+
+ sigc::slot<void> foo = sigc::bind(sigc::ptr_fun(Foo), std::ref(*t));
+ foo();
+ util->check_result(result_stream, "Foo(x)");
+
+ // This invalidates foo.
+ delete t;
+
+ // Try to crash if the invalid slot parameter is used by libsigc++,
+ // and get a debugger backtrace at the point that it happens.
+ //
+ // Comment this out to get a meaningful backtrace from valgrind.
+ //
+ // Try to pollute the memory previously occupied by the sigc::trackable
+ // instance. The hope is that with a regular memory allocator (i.e. not
+ // valgrind), we end up with buffer == (void *)t.
+ void* buffer = malloc(sizeof(sigc::trackable));
+ memset(buffer, 0xFF, sizeof(sigc::trackable));
+ pointer_stream << buffer;
+ result_stream << " Polluted buffer at " << pointer_stream.str();
+ util->check_result(result_stream, " Polluted buffer at " + pointer_stream.str());
+ pointer_stream.str("");
+
+ // 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<void> bar = foo;
+ bar();
+ util->check_result(result_stream, "");
+
+ free(buffer);
+
+ return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
--- /dev/null
+/* Copyright (C) 2012 The libsigc++ Development Team
+ *
+ * This file is part of libsigc++.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+// The purpose of this test case is threefold.
+// - Test that C++11 lambda expressions can be used in connection with sigc::slot
+// and sigc::signal.
+// - Show that libsigc++ lambda expressions can be replaced by C++11 lambda
+// expressions. It's shown here as a preparation for deprecating and eventually
+// deleting the libsigc++ lambda expressions.
+// See https://bugzilla.gnome.org/show_bug.cgi?id=672555
+// - Test the code examples in the documentation in sigc++/adaptors/lambda/base.h
+// and sigc++/adaptors/lambda/group.h.
+//
+// At present (August 2012) this test case contains approximately the same tests
+// as test_lambda.cc, but with libsigc++ lambda expressions replaced by C++11
+// lambda expressions, where possible.
+// 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(),
+// 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
+// versions of gcc; gcc 4.7.x also understands -std=c++11):
+// make CXXFLAGS='-g -O2 -std=c++0x' test_cpp11_lambda
+// ./test_cpp11_lambda
+// echo $?
+// If test_cpp11_lambda writes nothing and the return code is 0, the test has passed.
+
+
+#include "testutilities.h"
+#include <string>
+#include <iostream>
+#include <sstream>
+#include <functional>
+#include <cstdlib>
+#include <sigc++/functors/functors.h>
+#include <sigc++/bind.h>
+#include <sigc++/reference_wrapper.h>
+#include <sigc++/adaptors/track_obj.h>
+#include <sigc++/signal.h>
+
+
+namespace
+{
+std::ostringstream result_stream;
+
+int foo(int i, int j)
+{
+ result_stream << "foo(int " << i << ", int " << j << ") ";
+ return 4*i + j;
+}
+
+void foo_void(int i)
+{
+ result_stream << "foo_void(int " << i << ")";
+}
+
+struct bar
+{
+ int test(int i, int j)
+ {
+ result_stream << "bar::test(int " << i << ", int " << j << ") ";
+ return 4*i + j;
+ }
+
+ void test_void(int i)
+ {
+ result_stream << "bar::test_void(int " << i << ")";
+ }
+};
+
+void egon(std::string& str)
+{
+ result_stream << "egon(string '" << str << "')";
+ str = "egon was here";
+}
+
+struct book : public sigc::trackable
+{
+ explicit book(const std::string& name) : name_(name) {}
+ operator std::string& () { return name_; }
+ std::string name_;
+};
+
+inline std::ostringstream& operator << (std::ostringstream& s, const book& b)
+{
+ s << b.name_;
+ return s;
+}
+
+void foo_group1(int i, int j)
+{
+ result_stream << "foo_group1(int " << i << ", int " << j << ")";
+}
+
+int bar_group1(int i)
+{
+ result_stream << "bar_group1(int " << i << ") ";
+ return i + 2;
+}
+
+void foo_group2(int i)
+{
+ result_stream << "foo_group2(int " << i << ")";
+}
+
+void foo_group3(int& i)
+{
+ result_stream << "foo_group3(int " << i << ")";
+ ++i;
+}
+
+struct bar_group4 : public sigc::trackable
+{
+};
+
+void foo_group4(bar_group4&)
+{
+ result_stream << "foo_group4(bar_group4&)";
+}
+
+} // 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;
+
+
+ // 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));
+ 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));
+ 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));
+ 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));
+ 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));
+ 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));
+ 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));
+ util->check_result(result_stream, "4");
+
+ //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;
+ util->check_result(result_stream, "4 1");
+
+ // 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)(std::ref(a));
+ // std::cout << "; a: " << a << std::endl;
+ result_stream << ([] (std::reference_wrapper<int> 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 << " " << 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));
+ result_stream << " " << a_outer;
+ util->check_result(result_stream, "8 4");
+
+ // std::cout << "((--(*(&_1)))*2)(ref(a)): " << ((--(*(&_1)))*2)(std::ref(a));
+ // std::cout << "; a: " << a << std::endl;
+ result_stream << ([] (std::reference_wrapper<int> 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 << " " << 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));
+ util->check_result(result_stream, "5");
+
+ //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));
+ 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));
+ 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): "
+ // << (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));
+ 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
+ // - 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
+ // (std::ref(std::cout) << sigc::constant(1) << sigc::var("\n"))();
+ [](){ result_stream << 1 << "\n"; }();
+ util->check_result(result_stream, "1\n");
+
+ //(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");
+
+ //(std::ref(std::cout) << sigc::static_cast_<int>(_1) << std::string("\n"))(1.234);
+ [](double a){ result_stream << static_cast<int>(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"; }();
+ 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");
+ 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<void, std::ostringstream&> sl1;
+ {
+ book guest_book("karl");
+ //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_obj([&guest_book](std::ostringstream& stream){ stream << guest_book << "\n"; }, guest_book);
+ sl1(result_stream);
+ util->check_result(result_stream, "karl\n");
+
+ } // auto-disconnect
+
+ sl1(result_stream);
+ util->check_result(result_stream, "");
+
+ // test group adaptor, here replaced by std::bind
+ bar the_bar;
+ //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;
+ 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)) (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);
+ 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;
+ 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;
+ result_stream << std::bind(&foo, 1, 2)();
+ util->check_result(result_stream, "foo(int 1, int 2) 6");
+
+ //(sigc::group(sigc::ptr_fun(&foo_void), 1)) ();
+ std::bind(sigc::ptr_fun(&foo_void), 1)();
+ util->check_result(result_stream, "foo_void(int 1)");
+
+ // std::bind() does not work well together with sigc::slot and sigc::signal::connect().
+ // std::bind() typically creates a functor whose operator()() is a variadic template.
+ // Our functor_trait can't deduce the result type of such a functor.
+ // If the result of std::bind() is assigned to a std::function, the created
+ // functor has an unambiguous operator()().
+
+ // auto-disconnect
+ sigc::slot<void> sl2;
+ {
+ book guest_book("karl");
+ //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();
+ util->check_result(result_stream, "egon(string 'karl')");
+
+ //std::cout << static_cast<std::string&>(guest_book) << std::endl;
+ result_stream << static_cast<std::string&>(guest_book);
+ util->check_result(result_stream, "egon was here");
+
+ } // auto-disconnect
+
+ sl2();
+ util->check_result(result_stream, "");
+
+ // More auto-disconnect
+ {
+ book guest_book("charlie");
+ //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();
+ util->check_result(result_stream, "egon(string 'charlie')");
+
+ //std::cout << static_cast<std::string&>(guest_book) << std::endl;
+ result_stream << static_cast<std::string&>(guest_book);
+ util->check_result(result_stream, "egon was here");
+
+ } // auto-disconnect
+
+ sl2();
+ 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);
+ util->check_result(result_stream, "foo(int 1, int 2) 6");
+
+ //(sigc::group(sigc::ptr_fun(&foo_void), _2)) (1, 2);
+ std::bind(&foo_void, std::placeholders::_2)(1, 2);
+ 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);
+ 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_<int>(_1), 2)) (1.234) << std::endl;
+ result_stream << ([] (double x) -> int { return foo(static_cast<int>(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
+ // libsigc++ examples in the documentation of libsigc++ lambdas and sigc::group.
+ // -----------------------------------------------------------------------------
+
+ //--- 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));
+ 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));
+ util->check_result(result_stream, "20");
+
+ //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));
+ util->check_result(result_stream, "70");
+
+ //int main(int argc, char* argv[])
+ //{
+ // int data;
+ // sigc::signal<int> readValue;
+ //
+ // readValue.connect(sigc::var(data));
+ //
+ // data = 3;
+ // std::cout << readValue() << std::endl; //Prints 3.
+ //
+ // data = 5;
+ // std::cout << readValue() << std::endl; //Prints 5.
+ //}
+ {
+ int data;
+ sigc::signal<int> readValue;
+
+ readValue.connect([&data] () -> int { return data; });
+
+ data = 3;
+ result_stream << readValue();
+ util->check_result(result_stream, "3");
+
+ data = 5;
+ result_stream << readValue();
+ util->check_result(result_stream, "5");
+ }
+
+ //--- 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)
+ 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)
+ 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);
+ 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);
+ 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);
+ 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);
+ util->check_result(result_stream, "foo_group1(int 18, int 2)");
+
+ {
+ sigc::signal<void,int,int> 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);
+ util->check_result(result_stream, "foo_group2(int 2)");
+ }
+
+ {
+ int some_int = 0;
+ sigc::signal<void> 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<void> some_signal;
+ {
+ bar_group4 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, std::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.emit();
+ util->check_result(result_stream, "foo_group4(bar_group4&)");
+ }
+ some_signal.emit();
+ util->check_result(result_stream, "");
+ }
+
+ return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
+} // end main()
--- /dev/null
+// 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 <sstream>
+#include <cstdlib>
+#include <sigc++/sigc++.h>
+
+namespace
+{
+std::ostringstream result_stream;
+
+} // 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;
+
+ result_stream << "Example result string";
+ util->check_result(result_stream, "Example result string");
+
+ return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
--- /dev/null
+// -*- c++ -*-
+/* Copyright 2002, The libsigc++ Development Team
+ * Assigned to public domain. Use as you wish without restriction.
+ */
+
+#include "testutilities.h"
+#include <sstream>
+#include <cstdlib>
+#include <sigc++/sigc++.h>
+
+namespace
+{
+std::ostringstream result_stream;
+
+template <class T>
+void bar(T)
+{
+ result_stream << "unknown";
+}
+
+template <>
+void bar<int>(int)
+{
+ result_stream << "int";
+}
+
+template <>
+void bar<double>(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<foo2, long>());
+ util->check_result(result_stream, "double");
+
+ bar(sigc::deduce_result_t<foo2, int, int>());
+ util->check_result(result_stream, "double");
+
+ bar(sigc::deduce_result_t<foo3, int, int>());
+ util->check_result(result_stream, "int");
+
+#ifdef FAIL
+ bar(sigc::deduce_result_t<foo2, int, int, int>());
+ util->check_result(result_stream, "double");
+#endif
+
+ return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
--- /dev/null
+/* Copyright 2002, The libsigc++ Development Team
+ * Assigned to public domain. Use as you wish without restriction.
+ */
+
+#include "testutilities.h"
+#include <sigc++/trackable.h>
+#include <sigc++/signal.h>
+#include <sigc++/connection.h>
+#include <sigc++/adaptors/compose.h>
+#include <sigc++/functors/ptr_fun.h>
+#include <sigc++/functors/mem_fun.h>
+#include <sstream>
+#include <cstdlib>
+
+//The Tru64 compiler seems to need this to avoid an unresolved symbol
+//See bug #161503
+#include <new>
+
+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;
+ }
+};
+
+void good_bye_world()
+{
+ result_stream << "Good bye world!";
+}
+
+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::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 boom()
+ {
+ result_stream << "boom!";
+ }
+
+ void emit()
+ {
+ sig.emit();
+ }
+
+ sigc::signal<void> sig;
+};
+
+} // 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<int, int> sig;
+ sigc::signal<int, int>::iterator confoo;
+ sigc::signal<int, int>::iterator 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));
+ 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.
+
+ 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));
+ 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) ");
+
+ 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
+ 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
+ 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 ...
+
+ {
+ A a2;
+ 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) ");
+ }
+ result_stream << "sig is empty (size=" << sig.size() << "): ";
+ sig(8);
+ util->check_result(result_stream, "sig is empty (size=0): ");
+
+ { // A slot# within a slot
+ A a2;
+ sigc::slot1<int, int> 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() << "): ";
+ sig(9);
+ 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);
+ util->check_result(result_stream, "sig is empty (size=0): ");
+
+ { // A slot within a slot
+ A a2;
+ sigc::slot<int, int> 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) ");
+ }
+ 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;
+ b->emit();
+ util->check_result(result_stream, "deleting a signal during emission... Good bye world!");
+
+ return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
--- /dev/null
+/* Copyright 2002, The libsigc++ Development Team
+ * Assigned to public domain. Use as you wish without restriction.
+ */
+
+#include "testutilities.h"
+#include <sigc++/trackable.h>
+#include <sigc++/signal.h>
+#include <sigc++/connection.h>
+#include <sigc++/functors/ptr_fun.h>
+#include <sigc++/functors/mem_fun.h>
+#include <sstream>
+#include <cstdlib>
+
+namespace
+{
+std::ostringstream result_stream;
+
+sigc::connection connection;
+
+class HandlerClass : public sigc::trackable
+{
+public:
+ void handler()
+ {
+ result_stream << "handler called";
+ connection.disconnect();
+ }
+};
+
+} // 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;
+
+ HandlerClass instance;
+
+ sigc::signal<void> 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");
+ signal_test.emit();
+ util->check_result(result_stream, "handler called");
+ result_stream << "Number of signal handlers after signal emission: " << signal_test.size();
+ util->check_result(result_stream, "Number of signal handlers after signal emission: 0");
+
+ return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
--- /dev/null
+/* Copyright 2002, The libsigc++ Development Team
+ * Assigned to public domain. Use as you wish without restriction.
+ */
+
+#include "testutilities.h"
+#include <sigc++/adaptors/exception_catch.h>
+#include <sstream>
+#include <stdexcept>
+#include <cstdlib>
+
+namespace
+{
+std::ostringstream result_stream;
+
+struct f : public sigc::functor_base
+{
+ typedef int result_type;
+
+ int operator()(int i)
+ {
+ result_stream << "f(int " << i << ") ";
+ throw std::range_error("out of range ");
+ }
+};
+
+struct g : public sigc::functor_base
+{
+ typedef int result_type;
+
+ int operator()()
+ {
+ result_stream << "g() ";
+ throw std::range_error("out of range ");
+ }
+};
+
+struct g_void : public sigc::functor_base
+{
+ typedef void result_type;
+
+ void operator()()
+ {
+ result_stream << "g_void() ";
+ throw std::range_error("out of range ");
+ }
+};
+
+struct my_catch
+{
+ int operator()()
+ {
+ try
+ {
+ throw;
+ }
+ catch (const std::range_error& e) // catch what types we know
+ {
+ result_stream << "caught " << e.what();
+ }
+ return 1;
+ // all else continues out.
+ }
+};
+
+} // 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;
+
+ result_stream << sigc::exception_catch(f(), my_catch())(2);
+ util->check_result(result_stream, "f(int 2) caught out of range 1");
+
+ 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
+ util->check_result(result_stream, "g_void() caught out of range ");
+
+ return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
--- /dev/null
+/* Copyright 2002, The libsigc++ Development Team
+ * Assigned to public domain. Use as you wish without restriction.
+ */
+
+#include "testutilities.h"
+#include <sstream>
+#include <cstdlib>
+#include <sigc++/adaptors/bind.h>
+#include <sigc++/adaptors/compose.h>
+#include <sigc++/functors/mem_fun.h>
+#include <sigc++/functors/ptr_fun.h>
+
+namespace
+{
+std::ostringstream result_stream;
+
+class trackable {};
+
+struct A : public trackable { A() {} };
+
+template <class T_type, bool I_derived = std::is_base_of<trackable,T_type>::value>
+struct with_trackable;
+
+template <class T_type>
+struct with_trackable<T_type,false>
+{
+ static void perform(const T_type&)
+ {
+ result_stream << "other ";
+ }
+};
+
+template <class T_type>
+struct with_trackable<T_type,true>
+{
+ 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 <class T>
+ void operator()(const T& t) const
+ {
+ with_trackable<T>::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), std::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<int>(print(), sigc::compose(sigc::bind(sigc::ptr_fun3(&foo), std::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<trackable>(print(), sigc::compose(sigc::bind(sigc::ptr_fun3(&foo), std::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;
+}
--- /dev/null
+// -*- c++ -*-
+/* Copyright 2002, The libsigc++ Development Team
+ * Assigned to public domain. Use as you wish without restriction.
+ */
+
+#include "testutilities.h"
+#include <sigc++/adaptors/hide.h>
+#include <sstream>
+#include <cstdlib>
+
+namespace
+{
+std::ostringstream result_stream;
+
+struct foo : public sigc::functor_base
+{
+ // choose a type that can hold all return values
+ typedef int result_type;
+
+ int operator()()
+ {
+ result_stream << "foo() ";
+ return true;
+ }
+
+ int operator()(int j)
+ {
+ result_stream << "foo(int " << j << ") ";
+ return 1 + j;
+ }
+};
+
+struct foo_void : public sigc::functor_base
+{
+ typedef void result_type;
+
+ void operator()()
+ {
+ result_stream << "foo_void()";
+ }
+};
+
+} // end anonymous namespace
+
+namespace sigc { SIGC_FUNCTOR_TRAIT(foo,bool) }
+
+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;
+
+ result_stream << sigc::hide<0>(foo())(1, 2);
+ util->check_result(result_stream, "foo(int 2) 3");
+
+ result_stream << sigc::hide<1>(foo())(1, 2);
+ util->check_result(result_stream, "foo(int 1) 2");
+
+ result_stream << sigc::hide<-1>(foo())(1);
+ util->check_result(result_stream, "foo() 1");
+
+ result_stream << sigc::hide(foo())(1);
+ util->check_result(result_stream, "foo() 1");
+
+ 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;
+}
--- /dev/null
+#include "testutilities.h"
+#include <sigc++/sigc++.h>
+#include <sstream>
+#include <cstdlib>
+
+namespace
+{
+std::ostringstream result_stream;
+
+class Base
+ : virtual public sigc::trackable
+{
+};
+
+class Base2
+{
+public:
+ virtual ~Base2()
+ {}
+};
+
+class Derived
+ : virtual public Base,
+ public Base2
+{
+public:
+ void method()
+ {
+ result_stream << "method()";
+ }
+};
+
+} // 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;
+
+ auto instance = new Derived();
+ sigc::slot<void> handler = sigc::mem_fun(*instance, &Derived::method);
+ handler();
+ util->check_result(result_stream, "method()");
+
+ auto param =
+ sigc::bind(sigc::slot<void, Derived&>(), std::ref(*instance));
+ param();
+ util->check_result(result_stream, "");
+
+ auto ret =
+ sigc::bind_return(sigc::slot<void>(), std::ref(*instance));
+ ret();
+ util->check_result(result_stream, "");
+
+ delete instance;
+
+ handler();
+ param();
+ ret();
+ util->check_result(result_stream, "");
+
+ return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
--- /dev/null
+// -*- c++ -*-
+/* Copyright 2002, The libsigc++ Development Team
+ * Assigned to public domain. Use as you wish without restriction.
+ */
+
+#include "testutilities.h"
+#include <sigc++/sigc++.h>
+#include <sstream>
+#include <cstdlib>
+
+// 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_const(int i1) const { result_stream << "test::foo_const(int " << i1 << ')'; }
+
+ void foo_volatile(float i1) volatile
+ {
+ result_stream << "test::foo_volatile(float " << i1 << ')';
+ }
+
+ void foo_const_volatile(double i1) const volatile
+ {
+ result_stream << "test::foo_const_volatile(double " << 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)
+ {
+ result_stream << "test::foo_overloaded(int " << i1 << ", int " << i2 << ')';
+ return 1.0;
+ }
+};
+
+} // end anonymous namespace
+
+void test_non_const()
+{
+ test t;
+ sigc::mem_fun (&test::foo)(t, 1);
+ util->check_result(result_stream, "test::foo(short 1)");
+}
+
+void test_const()
+{
+ test t;
+ sigc::mem_fun (&test::foo_const)(t, 2);
+ util->check_result(result_stream, "test::foo_const(int 2)");
+}
+
+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)");
+}
+
+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)");
+}
+
+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)");
+}
+
+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)");
+}
+
+#if ENABLE_TEST_OF_OVERLOADED_FUNCTIONS
+void test_overloaded()
+{
+ test t;
+ sigc::mem_fun<char> (&test::foo_overloaded)(t, 7);
+ util->check_result(result_stream, "test::foo_overloaded(char 7)");
+
+ sigc::mem_fun<short> (&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_fun (&test::foo_overloaded)(t, 7, 8);
+ util->check_result(result_stream, "test::foo_overloaded(int 7, int 8)");
+}
+#endif
+
+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_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)");
+
+#if ENABLE_TEST_OF_OVERLOADED_FUNCTIONS
+ sigc::mem_fun(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)");
+#endif
+}
+
+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<void()> slot_of_member_method;
+ {
+ TestAutoDisconnect t;
+ slot_of_member_method = sigc::mem_fun(t, &TestAutoDisconnect::foo);
+
+ //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();
+
+#if ENABLE_TEST_OF_OVERLOADED_FUNCTIONS
+ test_overload();
+#endif
+
+ test_bound();
+
+ test_auto_disconnect();
+
+ return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
--- /dev/null
+// -*- c++ -*-
+/* Copyright 2002, The libsigc++ Development Team
+ * Assigned to public domain. Use as you wish without restriction.
+ */
+
+#include "testutilities.h"
+#include <sstream>
+#include <sigc++/sigc++.h>
+#include <cstdlib>
+
+//TODO: put something like #ifndef FORTE ... #else ... #endif around:
+#define ENABLE_TEST_OF_OVERLOADED_FUNCTIONS 0
+
+namespace
+{
+std::ostringstream result_stream;
+
+int foo()
+{
+ result_stream << "foo()";
+ return 1;
+}
+
+void foo(int i1)
+{
+ result_stream << "foo(int " << i1 << ")";
+}
+
+#if ENABLE_TEST_OF_OVERLOADED_FUNCTIONS
+void bar(char i1)
+{
+ result_stream << "bar(char " << (int)i1 << ")";
+}
+#endif
+
+void bar(float i1)
+{
+ result_stream << "bar(float " << i1 << ")";
+}
+
+double bar(int i1, int i2)
+{
+ result_stream << "bar(int " << i1 << ", int " << i2 << ")";
+ return 1.0f;
+}
+
+struct test
+{
+ static void foo()
+ {
+ result_stream << "test::foo()";
+ }
+};
+
+} // 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::ptr_fun0(&foo)();
+ util->check_result(result_stream, "foo()");
+
+ sigc::ptr_fun1(&foo)(1);
+ util->check_result(result_stream, "foo(int 1)");
+
+#if ENABLE_TEST_OF_OVERLOADED_FUNCTIONS
+ sigc::ptr_fun1<char>(&bar)(2);
+ util->check_result(result_stream, "bar(char 2)");
+
+ sigc::ptr_fun1<float>(&bar)(2.0f);
+ util->check_result(result_stream, "bar(float 2)");
+#else
+ sigc::ptr_fun1(&bar)(2.0f);
+ util->check_result(result_stream, "bar(float 2)");
+#endif
+
+ sigc::ptr_fun2(&bar)(3, 5);
+ util->check_result(result_stream, "bar(int 3, int 5)");
+
+ sigc::ptr_fun(&test::foo)();
+ util->check_result(result_stream, "test::foo()");
+
+ return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
--- /dev/null
+// -*- c++ -*-
+/* Copyright 2002, The libsigc++ Development Team
+ * Assigned to public domain. Use as you wish without restriction.
+ */
+
+#include "testutilities.h"
+#include <sigc++/adaptors/retype.h>
+#include <sstream>
+#include <cstdlib>
+
+namespace
+{
+
+TestUtilities* util = nullptr;
+std::ostringstream result_stream;
+
+struct foo : public sigc::trackable
+{
+ float test_int(int i)
+ {
+ result_stream << "foo::test_int(int " << i << ") ";
+ return i * 1.5f;
+ }
+
+ float test_float(float f)
+ {
+ result_stream << "foo::test_float(float " << f << ") ";
+ return f * 5;
+ }
+};
+
+void bar(short s)
+{
+ result_stream << "bar(short " << s << ")";
+}
+
+void test_member_int()
+{
+ 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)");
+}
+
+void test_member_int_with_slot()
+{
+ foo foo_;
+ sigc::slot<float,float> 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<float,int> 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<void,double> s3 = sigc::retype(sigc::ptr_fun(&bar));
+ s3(6.789);
+ util->check_result(result_stream, "bar(short 6)");
+}
+
+void test_retype_slot()
+{
+ foo foo_;
+ sigc::slot<float,float> s1 = sigc::retype(sigc::mem_fun(foo_, &foo::test_int));
+ sigc::slot<float,int> s2 = sigc::retype(s1);
+ result_stream << s2(5);
+ util->check_result(result_stream, "foo::test_int(int 5) 7.5");
+}
+
+void test_std_function_style_syntax()
+{
+ foo foo_;
+ sigc::slot<float(float)> 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");
+}
+
+} // 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();
+
+ test_std_function_style_syntax();
+
+ return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
--- /dev/null
+// -*- c++ -*-
+/* Copyright 2002, The libsigc++ Development Team
+ * Assigned to public domain. Use as you wish without restriction.
+ */
+
+#include "testutilities.h"
+#include <sigc++/adaptors/retype_return.h>
+#include <sigc++/functors/slot.h>
+#include <sstream>
+#include <cstdlib>
+
+namespace
+{
+std::ostringstream result_stream;
+
+struct foo : public sigc::functor_base
+{
+ typedef float result_type;
+
+ float operator()(int i)
+ {
+ result_stream << "foo(int " << i << ") ";
+ return i;
+ }
+
+ float operator()(float i)
+ {
+ result_stream << "foo(float " << i << ") ";
+ return i * 5;
+ }
+};
+
+struct bar : public sigc::trackable, public sigc::functor_base
+{
+ typedef int result_type;
+
+ int operator()(int i)
+ {
+ result_stream << "bar(int " << i << ")";
+ return i;
+ }
+};
+
+} // 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;
+
+ // retype_return<int>
+ result_stream << sigc::retype_return<int>(foo())(1.234f);
+ util->check_result(result_stream, "foo(float 1.234) 6");
+
+ // retype_return<void> / hide_return
+ sigc::slot<void, int> sl;
+ sl = sigc::retype_return<void>(bar());
+ sl(5);
+ util->check_result(result_stream, "bar(int 5)");
+
+ sl = sigc::hide_return(bar());
+ sl(6);
+ util->check_result(result_stream, "bar(int 6)");
+
+ return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
--- /dev/null
+// -*- c++ -*-
+/* Copyright 2002, The libsigc++ Development Team
+ * Assigned to public domain. Use as you wish without restriction.
+ */
+
+#include "testutilities.h"
+#include <sigc++/trackable.h>
+#include <sigc++/signal.h>
+#include <sigc++/functors/ptr_fun.h>
+#include <sigc++/functors/mem_fun.h>
+#include <string>
+#include <cstdlib>
+
+namespace
+{
+
+TestUtilities* util = nullptr;
+std::ostringstream result_stream;
+
+int foo(int i)
+{
+ result_stream << "foo(int " << i << ") ";
+ return 1;
+}
+
+struct A : public sigc::trackable
+{
+ int foo(int i)
+ {
+ result_stream << "A::foo(int " << i << ") ";
+ return 1;
+ }
+
+ void bar(std::string& str)
+ {
+ result_stream << "A::foo(string '" << str << "') ";
+ str = "foo was here";
+ }
+};
+
+void test_empty_signal()
+{
+ // signal
+ sigc::signal<int,int> sig;
+
+ // emit empty signal
+ sig(0);
+ util->check_result(result_stream, "");
+}
+
+void test_simple()
+{
+ sigc::signal<int, int> sig;
+ sig.connect(sigc::ptr_fun(&foo));
+
+ sig(1);
+ util->check_result(result_stream, "foo(int 1) ");
+}
+
+int bar(float i)
+{
+ result_stream << "bar(float " << i << ") ";
+ return 1;
+}
+
+void test_auto_disconnection()
+{
+ // signal
+ sigc::signal<int,int> 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(1);
+ result_stream << sig.size();
+ util->check_result(result_stream, "foo(int 1) A::foo(int 1) bar(float 1) 3");
+
+ } // a dies => auto-disconnect
+
+ sig(2);
+ result_stream << sig.size();
+ util->check_result(result_stream, "foo(int 2) bar(float 2) 2");
+}
+
+void test_reference()
+{
+ // test reference
+ A a;
+ std::string str("guest book");
+ sigc::signal<void,std::string&> 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()
+ sigc::signal<int,int> sig;
+ sig.connect(sigc::ptr_fun1(&foo));
+ sig.connect(sigc::ptr_fun(&bar));
+ sig.connect(sigc::ptr_fun(&foo));
+
+ sigc::signal<int,int> sig2;
+ sig2.connect(sig.make_slot());
+ sig2(3);
+ util->check_result(result_stream, "foo(int 3) bar(float 3) foo(int 3) ");
+}
+
+void test_std_function_style_syntax()
+{
+ sigc::signal<int(int)> sig;
+ sig.connect(sigc::ptr_fun(&foo));
+
+ sig(1);
+ util->check_result(result_stream, "foo(int 1) ");
+}
+
+void test_clear_called_in_signal_handler()
+{
+ sigc::signal<void()> 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<void()> 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_reference();
+ test_make_slot();
+ test_std_function_style_syntax();
+ test_clear_called_in_signal_handler();
+ test_clear_called_outside_signal_handler();
+
+ return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
--- /dev/null
+/* Copyright 2015, The libsigc++ Development Team
+ * Assigned to public domain. Use as you wish without restriction.
+ */
+
+#include "testutilities.h"
+#include <sigc++/trackable.h>
+#include <sigc++/signal.h>
+#include <sigc++/functors/ptr_fun.h>
+#include <sigc++/functors/mem_fun.h>
+#include <string>
+#include <cstdlib>
+
+namespace
+{
+std::ostringstream result_stream;
+
+int foo(int i)
+{
+ result_stream << "foo(int " << 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;
+
+ // signal
+ sigc::signal<int, int> sig;
+ sig.connect(sigc::ptr_fun(&foo));
+ sig(1);
+ util->check_result(result_stream, "foo(int 1)");
+
+ //Test the move constructor:
+ sigc::signal<int, int> sig2(std::move(sig));
+ sig(-2);
+ sig2(2);
+ util->check_result(result_stream, "foo(int 2)");
+
+ //Test the move assignment operator:
+ sigc::signal<int, int> sig3;
+ sig3 = std::move(sig2);
+ sig2(-3);
+ sig3(3);
+ util->check_result(result_stream, "foo(int 3)");
+
+ return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
--- /dev/null
+// -*- c++ -*-
+/* Copyright 2002, The libsigc++ Development Team
+ * Assigned to public domain. Use as you wish without restriction.
+ */
+
+#include "testutilities.h"
+#include <sigc++/sigc++.h>
+#include <iostream>
+#include <cstdlib>
+
+// The correct result of this test may be implementation-dependent.
+// No attempt is made to decide if the result is correct.
+// The test will succeed, unless it's started with erroneous command arguments.
+// "./test_size --verbose" shows the sizes.
+
+namespace
+{
+struct A
+{
+ void foo();
+};
+} // 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;
+
+ if (util->get_verbose())
+ {
+ std::cout << "sizes of public classes:" << std::endl;
+
+ std::cout << " trackable: " << sizeof(sigc::trackable) << std::endl;
+ std::cout << " slot<void>: " << sizeof(sigc::slot<void>) << std::endl;
+ std::cout << " signal<void>: " << sizeof(sigc::signal<void>) << std::endl;
+ std::cout << " signal<void>::iterator: " << sizeof(sigc::signal<void>::iterator) << std::endl;
+ 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;
+ std::cout << " slot_rep: " << sizeof(sigc::internal::slot_rep) << std::endl;
+ std::cout << " typed_slot_rep<mem_functor0<void,A> >: "
+ << sizeof(sigc::internal::typed_slot_rep<sigc::mem_functor0<void,A> >) << std::endl;
+ std::cout << " signal_impl: " << sizeof(sigc::internal::signal_impl) << std::endl;
+ }
+ return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
--- /dev/null
+/* Copyright 2002, The libsigc++ Development Team
+ * Assigned to public domain. Use as you wish without restriction.
+ */
+
+#include "testutilities.h"
+#include <sigc++/functors/slot.h>
+#include <sstream>
+#include <string>
+#include <cstdlib>
+
+//The Tru64 compiler seems to need this to avoid an unresolved symbol
+//See bug #161503
+#include <new>
+
+namespace
+{
+
+TestUtilities* util = nullptr;
+std::ostringstream result_stream;
+
+class foo
+{
+public:
+ void operator()(int i)
+ {
+ result_stream << "foo(int " << i << ")";
+ }
+
+ void operator()(std::string& str)
+ {
+ result_stream << "foo(string '" << str << "') ";
+ str="foo was here";
+ }
+
+ void operator()(int, int)
+ {
+ result_stream << "foo(int, int)";
+ }
+};
+
+void test_simple()
+{
+ // simple test
+ sigc::slot<void,int> 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_std_function_style_syntax()
+{
+ // simple test
+ sigc::slot<void(int)> 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<void,char> s2 = foo();
+ s2(3);
+ util->check_result(result_stream, "foo(int 3)");
+}
+
+void test_reference()
+{
+ // test reference
+ sigc::slot<void,std::string&> 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=
+ std::string str = "guest book";
+ sigc::slot<void,std::string&> sl1 = foo();
+ sigc::slot<void,std::string&> 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<void,int> s1 = foo();
+ sigc::slot<void,int> 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_std_function_style_syntax();
+ test_implicit_conversion();
+ test_reference();
+ test_operator_equals();
+ test_copy_ctor();
+
+ return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
--- /dev/null
+/* Copyright 2005, The libsigc++ Development Team
+ * Assigned to public domain. Use as you wish without restriction.
+ */
+
+#include "testutilities.h"
+#include <sigc++/functors/slot.h>
+#include <sstream>
+#include <string>
+#include <cstdlib>
+
+namespace
+{
+std::ostringstream result_stream;
+
+void Foo()
+{
+ result_stream << "Foo";
+}
+
+void Bar()
+{
+ result_stream << "Bar";
+}
+
+} // 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;
+
+ //Note that sigc::ptr_fun() creates a sigc::pointer_functor0.
+ sigc::slot<void> theSlot(sigc::ptr_fun(&Foo));
+ theSlot();
+ util->check_result(result_stream, "Foo");
+
+ theSlot.disconnect();
+ theSlot();
+ util->check_result(result_stream, "");
+
+ theSlot = sigc::ptr_fun(&Bar);
+ theSlot();
+ util->check_result(result_stream, "Bar");
+
+ theSlot = sigc::slot<void>(); // Assign an empty slot.
+ theSlot();
+ util->check_result(result_stream, "");
+
+ return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
--- /dev/null
+/* Copyright 2015, The libsigc++ Development Team
+ * Assigned to public domain. Use as you wish without restriction.
+ */
+
+#include "testutilities.h"
+#include <sigc++/functors/slot.h>
+#include <sstream>
+#include <string>
+#include <cstdlib>
+
+//The Tru64 compiler seems to need this to avoid an unresolved symbol
+//See bug #161503
+#include <new>
+
+namespace
+{
+std::ostringstream result_stream;
+
+class foo
+{
+public:
+ void operator()(int i)
+ {
+ result_stream << "foo(int " << i << ")";
+ }
+
+ void operator()(std::string& str)
+ {
+ result_stream << "foo(string '" << str << "') ";
+ str="foo was here";
+ }
+
+ void operator()(int, int)
+ {
+ result_stream << "foo(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;
+
+ // simple test
+ sigc::slot<void,int> s1 = foo();
+ s1(1);
+ util->check_result(result_stream, "foo(int 1)");
+
+ // test move constructor:
+ sigc::slot<void,int> s2(std::move(s1));
+ s1(-2);
+ s2(2);
+ util->check_result(result_stream, "foo(int 2)");
+
+ // test move assignment:
+ sigc::slot<void,int> s3;
+ s3 = std::move(s2);
+ s2(-3);
+ s3(3);
+ util->check_result(result_stream, "foo(int 3)");
+
+ return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
--- /dev/null
+/* Copyright (C) 2013 The libsigc++ Development Team
+ *
+ * This file is part of libsigc++.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+// The purpose of this test case is threefold.
+// - Test sigc::track_obj().
+// - 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 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.
+
+
+#include "testutilities.h"
+#include <string>
+#include <iostream>
+#include <sstream>
+#include <cstdlib>
+#include <sigc++/adaptors/track_obj.h>
+#include <sigc++/signal.h>
+
+
+namespace
+{
+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_; }
+ std::string name_;
+};
+
+struct bar_group4 : public sigc::trackable
+{
+};
+
+class Functor1 : public sigc::functor_base
+{
+public:
+ typedef std::string result_type;
+
+ Functor1(const bar_group4& bar)
+ : bar_(bar) {}
+
+ std::string operator()(int i)
+ {
+ return (i<0) ? "negative" : ((i>0) ? "positive" : "zero");
+ }
+
+protected:
+ // Don't make it private. clang++ does not like unused private data.
+ const bar_group4& bar_;
+};
+
+class Functor2 : public sigc::functor_base
+{
+public:
+ typedef std::string result_type;
+
+ 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, ");
+ result += str;
+ result += aBook_;
+ return result;
+ }
+
+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:
+
+inline std::ostringstream& operator << (std::ostringstream& s, const book& b)
+{
+ s << b.name_;
+ return s;
+}
+
+void egon(std::string& str)
+{
+ result_stream << "egon(string '" << str << "')";
+ str = "egon was here";
+}
+
+void foo_group4(bar_group4&)
+{
+ result_stream << "foo_group4(bar_group4&)";
+}
+
+} // 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::slot<std::string, int> sl1;
+ {
+ bar_group4 bar4;
+ sl1 = sigc::track_obj(Functor1(bar4), bar4);
+ result_stream << sl1(-2);
+ util->check_result(result_stream, "negative");
+
+ } // auto-disconnect sl1
+
+ result_stream << sl1(-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<std::string, int, std::string>;
+ 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
+ pbook4 = nullptr;
+ result_stream << (*psl2)(0, "Book title: ");
+ util->check_result(result_stream, "");
+ delete psl2;
+ psl2 = nullptr;
+ delete pbar4;
+ pbar4 = nullptr;
+
+
+//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<void, std::ostringstream&> sl10;
+ {
+ 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);
+ util->check_result(result_stream, "");
+
+ // auto-disconnect
+ sigc::slot<void> sl20;
+ {
+ 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')");
+
+ result_stream << static_cast<const std::string&>(guest_book);
+ util->check_result(result_stream, "egon was here");
+
+ } // auto-disconnect sl20
+
+ sl20();
+ util->check_result(result_stream, "");
+
+
+ // Code example in the documentation sigc++/adaptors/macros/track_obj.h.m4
+ // -----------------------------------------------------------------------
+ {
+ //struct bar : public sigc::trackable {} some_bar;
+ sigc::signal<void> some_signal;
+ {
+ bar_group4 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, std::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.emit();
+ util->check_result(result_stream, "foo_group4(bar_group4&)");
+
+ } // auto-disconnect the lambda expression
+
+ some_signal.emit();
+ util->check_result(result_stream, "");
+ }
+
+
+ return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
--- /dev/null
+// -*- c++ -*-
+/* Copyright 2002, The libsigc++ Development Team
+ * Assigned to public domain. Use as you wish without restriction.
+ */
+
+#include "testutilities.h"
+#include <sstream>
+#include <cstdlib>
+#include <sigc++/trackable.h>
+#include <sigc++/functors/slot.h>
+#include <sigc++/functors/mem_fun.h>
+
+namespace
+{
+std::ostringstream result_stream;
+
+class my_class: public sigc::trackable
+{
+public:
+ int i;
+
+ void foo()
+ {
+ result_stream << i;
+ }
+};
+
+} // 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::slot<void> sl;
+ {
+ my_class t;
+ t.i = 10;
+ sl = sigc::mem_fun0(t, &my_class::foo);
+ sl();
+ util->check_result(result_stream, "10");
+ }
+
+ sl();
+ util->check_result(result_stream, "");
+
+ return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
--- /dev/null
+// -*- c++ -*-
+/* Copyright 2002, The libsigc++ Development Team
+ * Assigned to public domain. Use as you wish without restriction.
+ */
+
+#include "testutilities.h"
+#include <sstream>
+#include <cstdlib>
+#include <sigc++/trackable.h>
+#include <sigc++/functors/slot.h>
+#include <sigc++/functors/mem_fun.h>
+
+namespace
+{
+std::ostringstream result_stream;
+
+class my_class: public sigc::trackable
+{
+public:
+
+ 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))
+ {
+ src.i = 0;
+ }
+
+ my_class& operator=(my_class&& src)
+ {
+ sigc::trackable::operator=(std::move(src));
+ i = std::move(src.i);
+ src.i = 0;
+ return *this;
+ }
+
+ void foo()
+ {
+ result_stream << i;
+ }
+
+ int i;
+};
+
+} // 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::slot<void> sl;
+ {
+ my_class t;
+ t.i = 10;
+ sl = sigc::mem_fun0(t, &my_class::foo);
+ sl();
+ util->check_result(result_stream, "10");
+
+ //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();
+ util->check_result(result_stream, "15");
+ }
+
+ return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
--- /dev/null
+/* Copyright (C) 2014 The libsigc++ Development Team
+ *
+ * This file is part of libsigc++.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "testutilities.h"
+#include <string>
+#include <iostream>
+#include <sstream>
+#include <cstdlib>
+#include <sigc++/signal.h>
+
+// 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.
+// SIGCTEST_CASE 2 Assume that class sigc::visitor has not been implemented.
+// Test with MyClass2, although it is expected to fail in this case.
+// SIGCTEST_CASE 3 Assume that class sigc::visitor has been implemented.
+// Test with MyClass2, which is expected to succeed in this case.
+// See also https://bugzilla.gnome.org/show_bug.cgi?id=724496
+#define SIGCTEST_CASE 3
+
+namespace
+{
+std::ostringstream result_stream;
+}
+
+// namespace assumed to belong to an external package.
+namespace ns_ext
+{
+class NsExtClass
+{
+};
+
+template <class T_action, class T_functor>
+void visit_each(T_action&, const T_functor&)
+{
+ result_stream << "ns_ext::visit_each() ";
+}
+
+} // end namespace ns_ext
+
+namespace
+{
+class MyClass1 : public sigc::trackable
+{
+public:
+ MyClass1(const std::string& str) : s(str) {}
+
+ void execute(int i)
+ {
+ result_stream << s << i;
+ }
+private:
+ std::string s;
+};
+
+class MyClass2 : public ns_ext::NsExtClass, public sigc::trackable
+{
+public:
+ MyClass2(const std::string& str) : s(str) {}
+
+ void execute(int i)
+ {
+ result_stream << s << i;
+ }
+private:
+ std::string s;
+};
+
+} // end anonymous namespace
+
+namespace ns1
+{
+// User-defined adaptor, as decribed in adaptor_trait.h.
+template <class T_functor>
+struct MyAdaptor1 : public sigc::adapts<T_functor>
+{
+ template <class T_arg1=void, class T_arg2=void>
+ struct deduce_result_type
+ { typedef sigc::deduce_result_t<T_functor, T_arg1, T_arg2> type; };
+ typedef typename sigc::functor_trait<T_functor>::result_type result_type;
+
+ result_type
+ operator()() const
+ {
+ result_stream << "MyAdaptor1()() ";
+ return this->functor_();
+ }
+
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ operator()(T_arg1 _A_arg1) const
+ {
+ result_stream << "MyAdaptor1()(_A_arg1) ";
+ return this->functor_(_A_arg1);
+ }
+
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2) const
+ {
+ result_stream << "MyAdaptor1()(_A_arg1, _A_arg2) ";
+ return this->functor_(_A_arg1, _A_arg2);
+ }
+
+ // Constructs a MyAdaptor1 object that wraps the passed functor.
+ // Initializes adapts<T_functor>::functor_, which is invoked from operator()().
+ explicit MyAdaptor1(const T_functor& _A_functor)
+ : sigc::adapts<T_functor>(_A_functor) {}
+};
+
+template <class T_action, class T_functor>
+void visit_each(const T_action& _A_action,
+ const MyAdaptor1<T_functor>& _A_target)
+{
+ visit_each(_A_action, _A_target.functor_);
+}
+
+template <typename T_functor>
+inline MyAdaptor1<T_functor>
+my_adaptor1(const T_functor& _A_func)
+{
+ return MyAdaptor1<T_functor>(_A_func);
+}
+
+} // end namespace ns1
+
+#if SIGCTEST_CASE >= 3
+// Specialization of sigc::visitor for MyAdaptor1.
+namespace sigc
+{
+template <class T_functor>
+struct visitor<ns1::MyAdaptor1<T_functor> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const ns1::MyAdaptor1<T_functor>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.functor_);
+ }
+};
+} // end namespace sigc
+#endif // SIGCTEST_CASE >= 3
+
+
+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<void, int> sl1;
+
+ {
+ MyClass1 my_class1("x=");
+ sl1 = sigc::mem_fun(my_class1, &MyClass1::execute);
+ sl1(-2);
+ util->check_result(result_stream, "x=-2");
+
+ } // auto-disconnect sl1
+
+ sl1(-2);
+ util->check_result(result_stream, "");
+
+#if SIGCTEST_CASE >= 2
+ {
+ MyClass2 my_class2("y=");
+ sl1 = sigc::mem_fun(my_class2, &MyClass2::execute);
+ sl1(2);
+ util->check_result(result_stream, "y=2");
+
+ } // auto-disconnect sl1
+
+ sl1(2);
+ util->check_result(result_stream, "");
+#endif // SIGCTEST_CASE >= 2
+
+ {
+ MyClass1 my_class3("a=");
+ sl1 = ns1::my_adaptor1(sigc::mem_fun(my_class3, &MyClass1::execute));
+ sl1(42);
+ util->check_result(result_stream, "MyAdaptor1()(_A_arg1) a=42");
+
+ } // auto-disconnect sl1
+
+ sl1(42);
+ util->check_result(result_stream, "");
+
+ return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
--- /dev/null
+/* Copyright (C) 2012 The libsigc++ Development Team
+ *
+ * This file is part of libsigc++.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "testutilities.h"
+
+#include <iostream>
+#include <cstring>
+
+TestUtilities* TestUtilities::instance_ = nullptr;
+
+TestUtilities::TestUtilities()
+: verbose_(false), result_ok_(true), test_number_(0)
+{
+}
+
+//static
+TestUtilities* TestUtilities::get_instance()
+{
+ if (!instance_)
+ instance_ = new TestUtilities;
+
+ return instance_;
+}
+
+bool TestUtilities::check_command_args(int argc, char* argv[])
+{
+ bool go_on = true; // Whether the caller shall continue program execution.
+ bool print_help = false;
+ for (int argi = 1; argi < argc; ++argi)
+ {
+ if (std::strcmp(argv[argi], "-v") == 0 || std::strcmp(argv[argi], "--verbose") == 0)
+ {
+ verbose_ = true;
+ }
+ else
+ {
+ print_help = true;
+ go_on = false;
+ if (!(std::strcmp(argv[argi], "-h") == 0 || std::strcmp(argv[argi], "--help") == 0))
+ {
+ result_ok_ = false;
+ std::cout << "Unknown command argument: " << argv[argi] << std::endl;
+ }
+ }
+ }
+
+ if (print_help)
+ std::cout << "Usage: " << argv[0] << " [-h|--help] [-v|--verbose]" << std::endl;
+
+ return go_on;
+}
+
+void TestUtilities::check_result(std::ostringstream& result_stream,
+ const std::string& expected_result)
+{
+ if (verbose_)
+ std::cout << result_stream.str() << std::endl;
+
+ ++test_number_;
+ if (expected_result != result_stream.str())
+ {
+ std::cerr << " Test " << test_number_ << std::endl;
+ std::cerr << "Expected \"" << expected_result << "\"" << std::endl;
+ std::cerr << "Got \"" << result_stream.str() << "\"" << std::endl;
+ result_ok_ = false;
+ }
+ result_stream.str("");
+}
+
+//static
+bool TestUtilities::get_result_and_delete_instance()
+{
+ const bool result = instance_ ? instance_->result_ok_ : true;
+ delete instance_;
+ instance_ = nullptr;
+ return result;
+}
--- /dev/null
+/* Copyright (C) 2012 The libsigc++ Development Team
+ *
+ * This file is part of libsigc++.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include <string>
+#include <sstream>
+
+// Functions used in several test cases in libsigc++.
+// This is a singleton class.
+class TestUtilities
+{
+public:
+
+ // Non-copyable:
+ TestUtilities(const TestUtilities&) = delete;
+ TestUtilities& operator=(const TestUtilities&) = delete;
+
+ // Non-movable:
+ TestUtilities(TestUtilities&&) = delete;
+ TestUtilities& operator=(TestUtilities&&) = delete;
+
+ static TestUtilities* get_instance();
+ bool check_command_args(int argc, char* argv[]);
+ void check_result(std::ostringstream& result_stream, const std::string& expected_result);
+ bool get_verbose() const { return verbose_; }
+ bool get_result() const { return result_ok_; }
+
+ // When you are searching for memory leaks with valgrind or a similar program,
+ // you avoid a harmless warning by deleting the instance when you're done with it.
+ static bool get_result_and_delete_instance();
+
+private:
+
+
+ TestUtilities();
+
+ static TestUtilities* instance_;
+ bool verbose_;
+ bool result_ok_;
+ int test_number_;
+};
--- /dev/null
+// Configuration-time test program, used in Meson build.
+// Corresponds to the M4 macro SIGC_CXX_GCC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD.
+
+#include <iostream>
+
+class Thing
+{
+ public:
+ Thing()
+ {}
+
+ template <class T>
+ void operator()(T a, T b)
+ {
+ T c = a + b;
+ std::cout << c << std::endl;
+ }
+};
+
+template<class T2>
+class OtherThing
+{
+public:
+ void do_something()
+ {
+ Thing thing_;
+ thing_.template operator()<T2>(1, 2);
+ //This fails with or without the template keyword, on SUN Forte C++ 5.3, 5.4, and 5.5:
+ }
+};
+
+int main()
+{
+ OtherThing<int> thing;
+ thing.do_something();
+ return 0;
+}
--- /dev/null
+#!/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 <subcommand> <xxx>...
+
+import os
+import sys
+import shutil
+import subprocess
+from pathlib import Path
+
+subcommand = sys.argv[1]
+
+# Invoked from custom_target() in meson.build.
+def build_from_m4():
+ # argv[2] argv[3] argv[4]
+ # <include_dir> <input_file> <output_file>
+
+ include_dir = sys.argv[2]
+ input_file = sys.argv[3]
+ output_file = sys.argv[4]
+
+ # Create the destination directory, if it does not exist.
+ output_dir = os.path.dirname(output_file)
+ os.makedirs(output_dir, exist_ok=True)
+
+ cmd = [
+ 'm4',
+ '-I', include_dir,
+ input_file,
+ ]
+ with open(output_file, mode='w') as output_file_obj:
+ return subprocess.run(cmd, stdout=output_file_obj).returncode
+
+# Invoked from meson.add_install_script().
+def install_built_h_files():
+ # argv[2] argv[3] argv[4:]
+ # <built_h_dir> <install_subdir> <built_h_files>...
+
+ # <built_h_dir> is an absolute path in the build directory or source directory.
+ # <install_subdir> is an installation directory, relative to {prefix}.
+ built_h_dir = sys.argv[2]
+ install_dir_root = os.path.join(os.getenv('MESON_INSTALL_DESTDIR_PREFIX'), sys.argv[3])
+
+ quiet = bool(os.getenv('MESON_INSTALL_QUIET'))
+ for file in sys.argv[4:]:
+ path_h = os.path.join(built_h_dir, file)
+ rel_dir = os.path.dirname(file)
+ if rel_dir:
+ install_dir = os.path.join(install_dir_root, rel_dir)
+ else:
+ install_dir = install_dir_root
+ if not quiet:
+ print('Installing ', path_h, ' to ', install_dir)
+
+ # Create the installation directory, if it does not exist.
+ os.makedirs(install_dir, exist_ok=True)
+
+ # shutil.copy2() copies timestamps and some other file metadata.
+ shutil.copy2(path_h, install_dir)
+ return 0
+
+# Invoked from meson.add_dist_script().
+def dist_built_files(is_msvc_files=False):
+ # argv[2] argv[3] argv[4:]
+ # <built_h_cc_dir> <dist_dir> <built_files>...
+
+ # <built_h_cc_dir> is an absolute path in the build directory or source directory.
+ # <dist_dir> 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
+
+# Invoked from run_command() in meson.build.
+def copy_built_files():
+ # argv[2] argv[3] argv[4:]
+ # <from_dir> <to_dir> <file_names>...
+
+ # <from_dir> is an absolute or relative path of the directory to copy from.
+ # <to_dir> is an absolute or relative path of the directory to copy to.
+ from_dir_root = sys.argv[2]
+ to_dir_root = sys.argv[3]
+
+ # Copy some built files if they exist in from_dir, but not in the destination
+ # directory, or if they are not up to date in the destination directory.
+ # (The term "source directory" is avoided here, because from_dir might not
+ # be what Meson calls a source directory as opposed to a build directory.)
+
+ # Copy .h and .cc files built from .m4 files.
+ for file in sys.argv[4:]:
+ from_file = os.path.join(from_dir_root, file)
+ to_file = os.path.join(to_dir_root, file)
+ if os.path.isfile(from_file) and ((not os.path.isfile(to_file))
+ or (os.stat(from_file).st_mtime > os.stat(to_file).st_mtime)):
+
+ # Create the destination directory, if it does not exist.
+ os.makedirs(os.path.dirname(to_file), exist_ok=True)
+
+ shutil.copy(from_file, to_file)
+ return 0
+
+# ----- Main -----
+if subcommand == 'build_from_m4':
+ sys.exit(build_from_m4())
+if subcommand == 'install_built_h_files':
+ sys.exit(install_built_h_files())
+if subcommand == 'dist_built_files':
+ sys.exit(dist_built_files())
+if subcommand == 'copy_built_files':
+ sys.exit(copy_built_files())
+if subcommand == 'dist_gen_msvc_files':
+ sys.exit(dist_built_files(True))
+print(sys.argv[0], ': illegal subcommand,', subcommand)
+sys.exit(1)
--- /dev/null
+// Configuration-time test program, used in Meson build.
+// Corresponds to the M4 macro SIGC_CXX_HAS_SUN_REVERSE_ITERATOR.
+
+#include <iterator>
+
+int main()
+{
+ typedef std::reverse_iterator<char*, std::random_access_iterator_tag, char, char&, char*, int> ReverseIter;
+ return 0;
+}
--- /dev/null
+// Configuration-time test program, used in Meson build.
+// Corresponds to the M4 macro SIGC_CXX_MSVC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD.
+
+#include <iostream>
+
+class Thing
+{
+ public:
+ Thing()
+ {}
+
+ template <class T>
+ void operator()(T a, T b)
+ {
+ T c = a + b;
+ std::cout << c << std::endl;
+ }
+};
+
+template<class T2>
+class OtherThing
+{
+public:
+ void do_something()
+ {
+ Thing thing_;
+ thing_.operator()<T2>(1, 2);
+ //This fails with or without the template keyword, on SUN Forte C++ 5.3, 5.4, and 5.5:
+ }
+};
+
+int main()
+{
+ OtherThing<int> thing;
+ thing.do_something();
+ return 0;
+}
--- /dev/null
+// Configuration-time test program, used in Meson build.
+// Corresponds to the M4 macro SIGC_CXX_PRAGMA_PUSH_POP_MACRO.
+
+#define BEGIN {
+#define END }
+#pragma push_macro("BEGIN")
+#pragma push_macro("END")
+#undef BEGIN
+#undef END
+
+// BEGIN and END are not prepreprocessor macros
+struct Test1
+{
+ int BEGIN;
+ double END;
+};
+
+#pragma pop_macro("BEGIN")
+#pragma pop_macro("END")
+
+// BEGIN and END are prepreprocessor macros
+struct Test2
+BEGIN
+ int i;
+ double d;
+END;
+
+void func1(Test1& x);
+void func2(Test2& x);
+
+int main()
+{
+ Test1 test1;
+ Test2 test2;
+ func1(test1);
+ func2(test2);
+ return 0;
+}
--- /dev/null
+#!/usr/bin/env python3
+
+# External command, intended to be called with custom_target() in meson.build
+
+# argv[1] argv[2:]
+# tutorial-custom-cmd.py <subcommand> <xxx>...
+
+import os
+import sys
+import subprocess
+import shutil
+
+subcommand = sys.argv[1]
+
+def html():
+ # argv[2] argv[3]
+ # <input_xml_file> <output_html_dir>
+
+ 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> <input_xml_file> <stamp_file_path>
+
+ 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]
+ # <input_xml_file> <output_pdf_file>
+ # 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',
+ ]
+
+ cmd = [
+ 'dblatex',
+ ] + dblatex_params + [
+ '-o', output_pdf_file,
+ '--pdf',
+ input_xml_file,
+ ]
+ return subprocess.run(cmd).returncode
+
+def fop():
+ # argv[2] argv[3]
+ # <input_xml_file> <output_pdf_file>
+ # 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]
+ # <doc_dist_dir> <doc_build_dir> <xml_file> <pdf_file>
+
+ # <doc_dist_dir> is a distribution directory, relative to MESON_PROJECT_DIST_ROOT.
+ # <doc_build_dir> is a relative or absolute path in the build directory.
+ # <xml_file> is a relative or absolute path in the source directory.
+ # <pdf_file> 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)
--- /dev/null
+/* This file is part of libsigc++. */
+#ifndef SIGCXXCONFIG_H_INCLUDED
+#define SIGCXXCONFIG_H_INCLUDED
+
+/* Define to omit deprecated API from the library. */
+/* #undef SIGCXX_DISABLE_DEPRECATED */
+
+/* Major version number of sigc++. */
+#define SIGCXX_MAJOR_VERSION 2
+
+/* Minor version number of sigc++. */
+#define SIGCXX_MINOR_VERSION 10
+
+/* Micro version number of sigc++. */
+#define SIGCXX_MICRO_VERSION 8
+
+/* 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
+#else /* !_WIN32 */
+# define SIGC_CONFIGURE 1
+#endif /* !_WIN32 */
+
+#ifdef SIGC_MSC
+/*
+ * MS VC7 Warning 4251 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)
+
+# 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
+
+#else /* SIGC_MSC */
+
+/* does the C++ compiler support the use of a particular specialization when
+ calling operator() template methods. */
+#define 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. */
+#define SIGC_MSVC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+/* does the C++ preprocessor support pragma push_macro() and pop_macro(). */
+#define 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
+#else /* !SIGC_DLL */
+# define SIGC_API
+#endif /* !SIGC_DLL */
+
+#endif /* !SIGCXXCONFIG_H_INCLUDED */
--- /dev/null
+
+#include <winver.h>
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION 2,10,8,1
+ PRODUCTVERSION 2,10,8,1
+ FILEFLAGSMASK 0
+ FILEFLAGS 0x0L
+ FILEOS VOS__WINDOWS32
+ FILETYPE VFT_DLL
+ FILESUBTYPE VFT2_UNKNOWN
+BEGIN
+ BLOCK "StringFileInfo"
+ BEGIN
+ BLOCK "040904b0"
+ BEGIN
+ VALUE "CompanyName", "The libsigc++ development team (see AUTHORS)"
+ VALUE "FileDescription", "The Typesafe Callback Framework for C++"
+ VALUE "FileVersion", "2.10.8"
+ VALUE "LegalCopyright", "Distribution is under the LGPL (see COPYING)"
+ VALUE "OriginalFilename", "sigc-2.0.dll"
+ VALUE "ProductName", "libsigc++"
+ VALUE "ProductVersion", "2.10.8"
+ END
+ END
+ BLOCK "VarFileInfo"
+ BEGIN
+ VALUE "Translation", 0x409, 1200
+ END
+END
--- /dev/null
+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/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/reference/libsigc++-2.0.devhelp2
+ libsigc++-2.0.tag
+ html/*
+untracked/docs/manual/libsigc_manual.pdf (only if build-pdf=true)
+ html/*
+untracked/MSVC_NMake/sigc.rc
+ sigc++config.h
+untracked/sigc++/*.h
+ adaptors/*.h
+ adaptors/lambda/*.h
+ adaptors/lambda/*.cc
+ functors/*.h
--- /dev/null
+#!/usr/bin/env python3
+#
+# Check for the first line in a file generated with gmmproc,
+# to see which gmmproc version was used, to see whether
+# to enable __declspec(dllexport to export symbols). This
+# is *not* intended for source files that are not generated
+# with gmmproc.
+#
+# Author: Chun-wei Fan April 2, 2020
+
+import argparse
+import os
+import sys
+
+min_required_gmmproc_ver = '2.64.3'
+
+parser = argparse.ArgumentParser(description='Check gmmproc version used.')
+parser.add_argument('--file',
+ dest='file',
+ help='Generated .cc/.h file to check gmmproc version')
+parser.add_argument('--gmmprocdir',
+ dest='gmmprocdir',
+ help='Directory where gmmproc is located')
+args = parser.parse_args()
+
+if args.file is None and args.gmmprocdir is None:
+ raise ValueError('Either --file or --gmmprocdir must be specified')
+
+if args.gmmprocdir is not None:
+ # gmmprocdir is specified: Check version string in gmmproc
+ gmmproc_path = os.path.join(args.gmmprocdir, 'gmmproc')
+ if not os.path.exists(gmmproc_path):
+ raise ValueError('A valid directory to locate gmmproc must be ' \
+ 'specified with --gmmprocdir=<directory>')
+
+ gmmproc_ver_str = None
+ with open(gmmproc_path, 'r') as f:
+ for line in f:
+ if line.startswith(' $main::glibmm_version = '):
+ gmmproc_ver_str = line[line.find('\"') + 1:line.rfind('\"')]
+
+ if gmmproc_ver_str is None:
+ raise ValueError('The gmmproc at %s is invalid' % gmmproc_path)
+
+ gmmproc_ver = gmmproc_ver_str.split('.')
+else:
+ # A pre-generated file is specified via --file
+ if not os.path.exists(args.file):
+ raise FileNotFoundError('File specified with --file does not exist')
+
+ # We only allow .h/.cc files to run this check
+ if not args.file.endswith('.cc') and \
+ not args.file.endswith('.h'):
+ raise ValueError('Only .cc/.h files are accepted here')
+
+ # Now grab the first line of the file we are checking for
+ f = open(args.file)
+ firstline = f.readline()
+ f.close()
+
+ # Check for gmmproc signature...
+ if not firstline.startswith('// Generated by gmmproc '):
+ raise ValueError('Specified file is not generated by gmmproc')
+
+ tokens = firstline.split()
+ gmmproc_ver = tokens[tokens.index('gmmproc') + 1].split('.')
+
+# Now compare the gmmproc version against the one we want
+# (2.64.3 or later)
+gmmproc_major = int(gmmproc_ver[0])
+gmmproc_minor = int(gmmproc_ver[1])
+gmmproc_micro = int(gmmproc_ver[2])
+
+min_required_ver = min_required_gmmproc_ver.split('.')
+min_major_ver = int(min_required_ver[0])
+min_minor_ver = int(min_required_ver[1])
+min_micro_ver = int(min_required_ver[2])
+
+if gmmproc_major > min_major_ver or \
+ (gmmproc_major == min_major_ver and \
+ gmmproc_minor > min_minor_ver) or \
+ (gmmproc_major == min_major_ver and \
+ gmmproc_minor == min_minor_ver and \
+ gmmproc_micro >= min_micro_ver):
+ sys.exit(0)
+else:
+ sys.exit(1)
--- /dev/null
+#!/usr/bin/env python3
+
+# External command, intended to be called with meson.add_dist_script() in meson.build
+
+# argv[1] argv[2] argv[3:]
+# dist-build-scripts.py <root_src_dir> <script_dir> <no_dist>...
+
+# <script_dir> The directory with the build scripts, relative to <root_source_dir>.
+# <no_dist> Zero or more names (relative to MESON_PROJECT_DIST_ROOT)
+# of files and directories that shall not be distributed.
+
+import os
+import sys
+import shutil
+
+# 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'))
+src_script_dir = os.path.join(sys.argv[1], sys.argv[2])
+dist_script_dir = os.path.join(project_dist_root, sys.argv[2])
+
+# Create the distribution script directory, if it does not exist.
+os.makedirs(dist_script_dir, exist_ok=True)
+
+# Distribute files that mm-common-get has copied to src_script_dir.
+files = [
+ 'check-dllexport-usage.py',
+ 'dist-build-scripts.py',
+ 'dist-changelog.py',
+ 'doc-reference.py',
+ 'generate-binding.py'
+]
+for file in files:
+ shutil.copy(os.path.join(src_script_dir, file), dist_script_dir)
+
+# Don't distribute .gitignore files.
+for dirpath, dirnames, filenames in os.walk(project_dist_root):
+ if '.gitignore' in filenames:
+ os.remove(os.path.join(dirpath, '.gitignore'))
+
+# Remove an empty MESON_PROJECT_DIST_ROOT/build directory.
+dist_build_dir = os.path.join(project_dist_root, 'build')
+if os.path.isdir(dist_build_dir):
+ try:
+ os.rmdir(dist_build_dir)
+ except OSError:
+ # Ignore the error, if not empty.
+ pass
+
+# Remove specified files and directories from the MESON_PROJECT_DIST_ROOT directory.
+for rel_path in sys.argv[3:]:
+ abs_path = os.path.join(project_dist_root, rel_path)
+ if os.path.isfile(abs_path):
+ os.remove(abs_path)
+ elif os.path.isdir(abs_path):
+ shutil.rmtree(abs_path, ignore_errors=True)
+ else:
+ # Ignore non-existent files and directories.
+ print('--- Info:', abs_path, 'not found, not removed.')
--- /dev/null
+#!/usr/bin/env python3
+
+# External command, intended to be called with meson.add_dist_script() in meson.build
+
+# argv[1]
+# dist-changelog.py <root_source_dir>
+
+import os
+import sys
+import subprocess
+
+# Make a ChangeLog file for distribution.
+cmd = [
+ 'git',
+ '--git-dir=' + os.path.join(sys.argv[1], '.git'),
+ '--work-tree=' + sys.argv[1],
+ 'log',
+ '--no-merges',
+ '--date=short',
+ '--max-count=200',
+ '--pretty=tformat:%cd %an <%ae>%n%n %s%n%w(0,0,2)%+b',
+]
+# 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'))
+logfilename = os.path.join(project_dist_root, 'ChangeLog')
+with open(logfilename, mode='w', encoding='utf-8') as logfile:
+ sys.exit(subprocess.run(cmd, stdout=logfile).returncode)
--- /dev/null
+#!/usr/bin/env python3
+
+# External command, intended to be called with run_command(), custom_target(),
+# meson.add_install_script() or meson.add_dist_script() in meson.build.
+
+# argv[1] argv[2] argv[3:]
+# doc-reference.py <subcommand> <MMDOCTOOLDIR> <xxx>...
+
+# <MMDOCTOOLDIR> is an absolute path in the source directory.
+
+import os
+import sys
+import subprocess
+import shutil
+
+subcommand = sys.argv[1]
+MMDOCTOOLDIR = sys.argv[2]
+
+# Invoked from custom_target() in meson.build.
+def doxygen():
+ # argv[3] argv[4:]
+ # <doxytagfile> <doc_input_files>...
+
+ # <doxytagfile> is a relative or absolute path in the build directory.
+ # <doc_input_files> are absolute paths in the source or build directory.
+ doxytagfile = sys.argv[3]
+ doc_outdir = os.path.dirname(doxytagfile)
+
+ # Search for doc_postprocess.py first in MMDOCTOOLDIR.
+ sys.path.insert(0, MMDOCTOOLDIR)
+ from doc_postprocess import doc_postprocess
+
+ # Export this variable for use in the Doxygen configuration file.
+ child_env = os.environ.copy()
+ child_env['MMDOCTOOLDIR'] = MMDOCTOOLDIR
+
+ # Remove old files.
+ if os.path.isfile(doxytagfile):
+ os.remove(doxytagfile)
+ shutil.rmtree(os.path.join(doc_outdir, 'html'), ignore_errors=True)
+
+ # Relative paths in Doxyfile assume that Doxygen is run from the
+ # build directory one level above Doxyfile.
+ doxygen_cwd = os.path.join(doc_outdir, '..')
+
+ DOXYGEN = child_env.get('DOXYGEN', None)
+ if not DOXYGEN:
+ DOXYGEN = 'doxygen'
+ doxygen_input = '@INCLUDE = ' + os.path.join('reference', 'Doxyfile') + '\n' \
+ + 'INPUT = "' + '" "'.join(sys.argv[4:]) + '"\n'
+ # (Starting with Python 3.7 text=True is a more understandable equivalent to
+ # universal_newlines=True. Let's use only features in Python 3.5.)
+ result = subprocess.run([DOXYGEN, '-'], input=doxygen_input,
+ universal_newlines=True, env=child_env, cwd=doxygen_cwd)
+ if result.returncode:
+ return result.returncode
+
+ return doc_postprocess(os.path.join(doc_outdir, 'html', '*.html'))
+
+# Invoked from custom_target() in meson.build.
+def devhelp():
+ # argv[3] argv[4] argv[5] argv[6]
+ # <doxytagfile> <devhelpfile> <book_name> <book_title>
+
+ # <doxytagfile> and <devhelpfile> are relative or absolute paths in the build directory.
+ doxytagfile = sys.argv[3]
+ devhelpfile = sys.argv[4]
+ book_name = sys.argv[5]
+ book_title = sys.argv[6]
+ tagfile_to_devhelp = os.path.join(MMDOCTOOLDIR, 'tagfile-to-devhelp2.xsl')
+
+ # The parameters to the Doxygen-to-Devhelp XSLT script.
+ cmd = [
+ 'xsltproc',
+ '--stringparam', 'book_title', book_title,
+ '--stringparam', 'book_name', book_name,
+ '--stringparam', 'book_base', 'html',
+ '-o', devhelpfile,
+ tagfile_to_devhelp,
+ doxytagfile,
+ ]
+ return subprocess.run(cmd).returncode
+
+# Invoked from meson.add_install_script().
+def install_doc():
+ # argv[3] argv[4] argv[5] argv[6:]
+ # <devhelpfile> <devhelpdir> <htmlrefdir> <docinstall_flags>...
+
+ # <devhelpfile> is a relative or absolute path in the build directory.
+ # <htmlrefdir> and <devhelpdir> are installation directories, relative to {prefix}.
+ devhelpfile = sys.argv[3]
+ destdir_devhelpdir = os.path.join(os.getenv('MESON_INSTALL_DESTDIR_PREFIX'), sys.argv[4])
+ destdir_htmlrefdir = os.path.join(os.getenv('MESON_INSTALL_DESTDIR_PREFIX'), sys.argv[5])
+ prefix_htmlrefdir = os.path.join(os.getenv('MESON_INSTALL_PREFIX'), sys.argv[5])
+ build_dir = os.path.dirname(devhelpfile)
+
+ # Search for doc_install.py first in MMDOCTOOLDIR.
+ sys.path.insert(0, MMDOCTOOLDIR)
+ from doc_install import doc_install_cmdargs, doc_install_funcargs
+
+ # Create the installation directories, if they do not exist.
+ os.makedirs(destdir_htmlrefdir, exist_ok=True)
+ os.makedirs(destdir_devhelpdir, exist_ok=True)
+
+ verbose = []
+ if not os.getenv('MESON_INSTALL_QUIET'):
+ verbose = ['--verbose']
+
+ # Install html files.
+ cmdargs = [
+ '--mode=0o644',
+ ] + verbose + sys.argv[6:] + [
+ '-t', destdir_htmlrefdir,
+ '--glob',
+ '--',
+ os.path.join(build_dir, 'html', '*'),
+ ]
+ result1 = doc_install_cmdargs(cmdargs)
+
+ # Install the Devhelp file.
+ # rstrip('/') means remove trailing /, if any.
+ result2 = doc_install_funcargs(
+ sources=[devhelpfile],
+ target=destdir_devhelpdir,
+ target_is_dir=True,
+ mode=0o644,
+ verbose=bool(verbose),
+ book_base=prefix_htmlrefdir.rstrip('/'),
+ )
+
+ return max(result1, result2)
+
+# Invoked from meson.add_dist_script().
+def dist_doc():
+ # argv[3] argv[4] argv[5] argv[6]
+ # <doctool_dist_dir> <doc_ref_build_dir> <tagfile> <devhelpfile>
+
+ # <doctool_dist_dir> is a distribution directory, relative to MESON_PROJECT_DIST_ROOT.
+ # <doc_ref_build_dir> is a relative or absolute path in the build directory.
+ # <tagfile> and <devhelpfile> are relative or absolute paths 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'))
+ doctool_dist_dir = os.path.join(project_dist_root, sys.argv[3])
+ doc_ref_build_dir = sys.argv[4]
+ tagfile = sys.argv[5]
+ devhelpfile = sys.argv[6]
+
+ # Create the distribution directory, if it does not exist.
+ os.makedirs(os.path.join(doctool_dist_dir, 'reference'), exist_ok=True)
+
+ # Distribute files that mm-common-get has copied to MMDOCTOOLDIR.
+ # shutil.copy() does not copy timestamps.
+ for file in ['doc_install.py', 'doc_postprocess.py', 'doxygen-extra.css', 'tagfile-to-devhelp2.xsl']:
+ shutil.copy(os.path.join(MMDOCTOOLDIR, file), doctool_dist_dir)
+
+ # Distribute built files: tag file, devhelp file, html files.
+ for file in [tagfile, devhelpfile]:
+ shutil.copy(file, os.path.join(doctool_dist_dir, 'reference'))
+ shutil.copytree(os.path.join(doc_ref_build_dir, 'html'),
+ os.path.join(doctool_dist_dir, 'reference', 'html'),
+ copy_function=shutil.copy)
+ return 0
+
+# Invoked from run_command() in meson.build.
+def get_script_property():
+ # argv[3]
+ # <property>
+ # argv[2] (MMDOCTOOLDIR) is not used.
+ prop = sys.argv[3]
+ if prop == 'requires_perl':
+ print('false', end='') # stdout can be read in the meson.build file.
+ return 0
+ print(sys.argv[0], ': unknown property,', prop)
+ return 1
+
+# ----- Main -----
+if subcommand == 'doxygen':
+ sys.exit(doxygen())
+if subcommand == 'devhelp':
+ sys.exit(devhelp())
+if subcommand == 'install_doc':
+ sys.exit(install_doc())
+if subcommand == 'dist_doc':
+ sys.exit(dist_doc())
+if subcommand == 'get_script_property':
+ sys.exit(get_script_property())
+print(sys.argv[0], ': illegal subcommand,', subcommand)
+sys.exit(1)
--- /dev/null
+#!/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:]
+# generate-binding.py <subcommand> <xxx>...
+
+import os
+import sys
+import subprocess
+from pathlib import Path
+import shutil
+
+subcommand = sys.argv[1]
+
+# Invoked from custom_target() in meson.build.
+def generate_wrap_init():
+ # argv[2] argv[3] argv[4] argv[5:]
+ # <gmmproc_dir> <output_file> <namespace> <hg_files>...
+
+ # <gmmproc_dir> is an absolute path in glibmm's installation directory.
+ # <output_file> is a relative or absolute path in the build directory.
+ # <hg_files> are relative or absolute paths in the source directory.
+ gmmproc_dir = sys.argv[2]
+ output_file = sys.argv[3]
+ parent_dir = os.path.basename(os.path.dirname(output_file))
+ namespace = sys.argv[4]
+ cmd = [
+ 'perl',
+ '--',
+ os.path.join(gmmproc_dir, 'generate_wrap_init.pl'),
+ '--namespace=' + namespace,
+ '--parent_dir=' + parent_dir,
+ ] + sys.argv[5:]
+ with open(output_file, mode='w', encoding='utf-8') as output_file_obj:
+ return subprocess.run(cmd, stdout=output_file_obj).returncode
+
+# Invoked from custom_target() in meson.build.
+def gmmproc():
+ # argv[2] argv[3] argv[4] argv[5] argv[6:]
+ # <gmmproc_dir> <output_file> <basefilename> <src_dir> <m4_dirs>...
+
+ # <gmmproc_dir> is an absolute path in glibmm's installation directory.
+ # <output_file> is a relative or absolute path in the build directory.
+ # <src_dir> is an absolute path in the source directory.
+ # <m4_dirs> are absolute paths in the source directory.
+ gmmproc_dir = sys.argv[2]
+ output_file = sys.argv[3]
+ output_dir = os.path.dirname(output_file)
+ basefilename = sys.argv[4] # name without filetype
+ src_dir = sys.argv[5]
+
+ include_m4_dirs = []
+ for dir in sys.argv[6:]:
+ include_m4_dirs += ['-I', dir]
+
+ # Create the private/ directory, if it does not exist.
+ os.makedirs(os.path.join(output_dir, 'private'), exist_ok=True)
+
+ # gmmproc generates output_dir/basefilename.cc, output_dir/basefilename.h
+ # and output_dir/private/{basefilename}_p.h
+ cmd = [
+ 'perl',
+ '-I' + os.path.join(gmmproc_dir, 'pm'),
+ '--',
+ os.path.join(gmmproc_dir, 'gmmproc'),
+ ] + include_m4_dirs + [
+ '--defs',
+ src_dir,
+ basefilename,
+ src_dir,
+ output_dir,
+ ]
+ result = subprocess.run(cmd)
+ if result.returncode:
+ return result.returncode
+
+ # gmmproc does not update the timestamps of output files that have not changed.
+ # That's by design, to avoid unnecessary recompilations.
+ # The updated timestamp of output_file shows meson that this custom_target()
+ # has been updated.
+ Path(output_file).touch(exist_ok=True)
+ return 0
+
+# Invoked from meson.add_install_script().
+def install_built_h_files():
+ # argv[2] argv[3] argv[4:]
+ # <built_h_dir> <install_subdir> <basefilenames>...
+
+ # <built_h_dir> is an absolute path in the build directory or source directory.
+ # <install_subdir> is an installation directory, relative to {prefix}.
+ built_h_dir = sys.argv[2]
+ install_dir = os.path.join(os.getenv('MESON_INSTALL_DESTDIR_PREFIX'), sys.argv[3])
+
+ # Create the installation directory, if it does not exist.
+ os.makedirs(os.path.join(install_dir, 'private'), exist_ok=True)
+
+ quiet = bool(os.getenv('MESON_INSTALL_QUIET'))
+ for file in sys.argv[4:]:
+ path_h = os.path.join(built_h_dir, file+'.h')
+ if not quiet:
+ print('Installing ', path_h, ' to ', install_dir)
+ # shutil.copy2() copies timestamps and some other file metadata.
+ shutil.copy2(path_h, install_dir)
+
+ path_h = os.path.join(built_h_dir, 'private', file+'_p.h')
+ install_priv_dir = os.path.join(install_dir, 'private')
+ if not quiet:
+ print('Installing ', path_h, ' to ', install_priv_dir)
+ shutil.copy2(path_h, install_priv_dir)
+ return 0
+
+# Invoked from meson.add_dist_script().
+def dist_built_files():
+ # argv[2] argv[3] argv[4:]
+ # <built_h_cc_dir> <dist_dir> <basefilenames>...
+
+ # <built_h_cc_dir> is an absolute path in the build directory or source directory.
+ # <dist_dir> 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 = os.path.join(project_dist_root, sys.argv[3])
+
+ # Create the distribution directory, if it does not exist.
+ os.makedirs(os.path.join(dist_dir, 'private'), exist_ok=True)
+
+ # Distribute wrap_init.cc.
+ # shutil.copy() does not copy timestamps.
+ shutil.copy(os.path.join(built_h_cc_dir, 'wrap_init.cc'), dist_dir)
+
+ # Distribute .h/.cc/_p.h files built from .hg/.ccg files.
+ for file in sys.argv[4:]:
+ shutil.copy(os.path.join(built_h_cc_dir, file+'.h'), dist_dir)
+ shutil.copy(os.path.join(built_h_cc_dir, file+'.cc'), dist_dir)
+ shutil.copy(os.path.join(built_h_cc_dir, 'private', file+'_p.h'),
+ os.path.join(dist_dir, 'private'))
+ return 0
+
+# Invoked from run_command() in meson.build.
+def copy_built_files():
+ # argv[2] argv[3] argv[4:]
+ # <from_dir> <to_dir> <basefilenames>...
+
+ # <from_dir> is an absolute or relative path of the directory to copy from.
+ # <to_dir> is an absolute or relative path of the directory to copy to.
+ from_dir = sys.argv[2]
+ to_dir = sys.argv[3]
+
+ # Create the destination directory, if it does not exist.
+ os.makedirs(os.path.join(to_dir, 'private'), exist_ok=True)
+
+ # Copy some built files if they exist in from_dir, but not in the destination
+ # directory, or if they are not up to date in the destination directory.
+ # (The term "source directory" is avoided here, because from_dir might not
+ # be what Meson calls a source directory as opposed to a build directory.)
+
+ # Copy wrap_init.cc.
+ from_file = os.path.join(from_dir, 'wrap_init.cc')
+ to_file = os.path.join(to_dir, 'wrap_init.cc')
+ if os.path.isfile(from_file) and ((not os.path.isfile(to_file))
+ or (os.stat(from_file).st_mtime > os.stat(to_file).st_mtime)):
+ shutil.copy(from_file, to_file)
+
+ # Copy .h/.cc/_p.h files built from .hg/.ccg files.
+ for basefile in sys.argv[4:]:
+ for file in [basefile+'.h', basefile+'.cc', os.path.join('private', basefile+'_p.h')]:
+ from_file = os.path.join(from_dir, file)
+ to_file = os.path.join(to_dir, file)
+ if os.path.isfile(from_file) and ((not os.path.isfile(to_file))
+ or (os.stat(from_file).st_mtime > os.stat(to_file).st_mtime)):
+ shutil.copy(from_file, to_file)
+ return 0
+
+# ----- Main -----
+if subcommand == 'generate_wrap_init':
+ sys.exit(generate_wrap_init())
+if subcommand == 'gmmproc':
+ sys.exit(gmmproc())
+if subcommand == 'install_built_h_files':
+ sys.exit(install_built_h_files())
+if subcommand == 'dist_built_files':
+ sys.exit(dist_built_files())
+if subcommand == 'copy_built_files':
+ sys.exit(copy_built_files())
+print(sys.argv[0], ': illegal subcommand,', subcommand)
+sys.exit(1)
--- /dev/null
+#!/usr/bin/env python3
+
+# doc_install.py [OPTION]... [-T] SOURCE DEST
+# doc_install.py [OPTION]... SOURCE... DIRECTORY
+# doc_install.py [OPTION]... -t DIRECTORY SOURCE...
+
+# Copy SOURCE to DEST or multiple SOURCE files to the existing DIRECTORY,
+# while setting permission modes. For HTML files, translate references to
+# external documentation.
+
+# Mandatory arguments to long options are mandatory for short options, too.
+# --book-base=BASEPATH use reference BASEPATH for Devhelp book
+# -l, --tag-base=TAGFILE\@BASEPATH use BASEPATH for references from TAGFILE (Doxygen <= 1.8.15)
+# -l, --tag-base=s\@BASEPUB\@BASEPATH substitute BASEPATH for BASEPUB (Doxygen >= 1.8.16)
+# -m, --mode=MODE override file permission MODE (octal)
+# -t, --target-directory=DIRECTORY copy all SOURCE arguments into DIRECTORY
+# -T, --no-target-directory treat DEST as normal file
+# --glob expand SOURCE as filename glob pattern
+# -v, --verbose enable informational messages
+# -h, --help display help and exit
+
+import os
+import sys
+import re
+import glob
+
+# Globals
+g_verbose = False
+tags_dict = {}
+subst_dict = {}
+perm_mode = 0o644
+g_book_base = None
+html_doxygen_count = 0
+
+message_prefix = os.path.basename(__file__) + ':'
+
+# The installed files are read and written in binary mode.
+# All regular expressions and replacement strings must be bytes objects.
+html_start_pattern = re.compile(rb'\s*(?:<[?!][^<]+)*<html[>\s]')
+html_split1_pattern = re.compile(rb'''
+ \bdoxygen="([^:"]+):([^"]*)" # doxygen="(TAGFILE):(BASEPATH)"
+ \s+((?:href|src)=")\2([^"]*") # (href="|src=")BASEPATH(RELPATH")
+ ''', re.VERBOSE)
+html_split2_pattern = re.compile(rb'''
+ \b((?:href|src)=")([^"]+") # (href="|src=")(BASEPUB RELPATH")
+ ''', re.VERBOSE)
+
+devhelp_start_pattern = re.compile(rb'\s*(?:<[?!][^<]+)*<book\s')
+devhelp_subst_pattern = re.compile(rb'(<book\s+[^<>]*?\bbase=")[^"]*(?=")')
+
+def notice(*msg):
+ if g_verbose:
+ print(message_prefix, ''.join(msg))
+
+def error(*msg):
+ print(message_prefix, 'Error:', ''.join(msg), file=sys.stderr)
+ raise RuntimeError(''.join(msg))
+
+def html_split1_func(group1, group2):
+ global html_doxygen_count
+ if group1 in tags_dict:
+ html_doxygen_count += 1
+ return tags_dict[group1]
+ return group2
+
+def html_split2_func(group2):
+ for key in subst_dict:
+ # Don't use regular expressions here. key may contain characters
+ # that are special in regular expressions.
+ if group2.startswith(key):
+ return subst_dict[key] + group2[len(key):]
+ return None
+
+def install_file(in_name, out_name):
+ '''
+ Copy file to destination while translating references on the fly.
+ '''
+ global html_doxygen_count
+
+ # Some installed files are binary (e.g. .png).
+ # Read and write all files in binary mode, thus avoiding decoding/encoding errors.
+ in_basename = os.path.basename(in_name)
+ with open(in_name, mode='rb') as in_file:
+ # Read the whole file into a string buffer.
+ buf = in_file.read()
+
+ if (tags_dict or subst_dict) and html_start_pattern.match(buf):
+ # Probably an html file. Modify it, if appropriate.
+ #
+ # It would be possible to modify with a call to Pattern.sub() or Pattern.subn()
+ # and let a function calculate the replacement string. Example:
+ # (buf, number_of_subs) = html_split2_pattern.subn(html_subst2_func, buf)
+ # A previous Perl script does just that. However, calling a function from
+ # sub() or subn() is a slow operation. Installing doc files for a typical
+ # module such as glibmm or gtkmm takes about 8 times as long as with the
+ # present split+join solution. (Measured with python 3.9.5)
+ html_doxygen_count = 0
+ number_of_subs = 0
+ change = 'no'
+ if tags_dict and b'doxygen="' in buf:
+ # Doxygen 1.8.15 and earlier stores the tag file name and BASEPATH in the html files.
+ split_buf = html_split1_pattern.split(buf)
+ for i in range(0, len(split_buf)-4, 5):
+ basepath = html_split1_func(split_buf[i+1], split_buf[i+2])
+ split_buf[i+1] = b''
+ split_buf[i+2] = b''
+ split_buf[i+3] += basepath
+ number_of_subs = len(split_buf) // 5
+ if number_of_subs > 0:
+ buf = b''.join(split_buf)
+ change = 'rewrote ' + str(html_doxygen_count) + ' of ' + str(number_of_subs)
+
+ if number_of_subs == 0 and subst_dict:
+ # Doxygen 1.8.16 and later does not store the tag file name and BASEPATH in the html files.
+ # The previous html_split1_pattern.split() won't find anything to substitute.
+ split_buf = html_split2_pattern.split(buf)
+ for i in range(2, len(split_buf), 3):
+ basepath = html_split2_func(split_buf[i])
+ if basepath:
+ split_buf[i] = basepath
+ html_doxygen_count += 1
+ number_of_subs = len(split_buf) // 3
+ if html_doxygen_count > 0:
+ buf = b''.join(split_buf)
+ if number_of_subs > 0:
+ change = 'rewrote ' + str(html_doxygen_count)
+ notice('Translating ', in_basename, ' (', change, ' references)')
+
+ elif g_book_base and devhelp_start_pattern.match(buf):
+ # Probably a devhelp file.
+ # Substitute new value for attribute "base" of element <book>.
+ (buf, number_of_subs) = devhelp_subst_pattern.subn(rb'\1' + g_book_base, buf, 1)
+ change = 'rewrote base path' if number_of_subs else 'base path not set'
+ notice('Translating ', in_basename, ' (', change, ')')
+ else:
+ # A file that shall not be modified.
+ notice('Copying ', in_basename)
+
+ with open(out_name, mode='wb') as out_file:
+ # Write the whole buffer into the target file.
+ out_file.write(buf)
+
+ os.chmod(out_name, perm_mode)
+
+def split_key_value(mapping):
+ '''
+ Split TAGFILE@BASEPATH or s@BASEPUB@BASEPATH argument into key/value pair
+ '''
+ (name, path) = mapping.split('@', 1)
+ if name != 's': # Doxygen 1.8.15 and earlier
+ if not name:
+ error('Invalid base path mapping: ', mapping)
+ if path != None:
+ return (name, path, False)
+ notice('Not changing base path for tag file ', name);
+
+ else: # name=='s', Doxygen 1.8.16 and later
+ (name, path) = path.split('@', 1)
+ if not name:
+ error('Invalid base path mapping: ', mapping)
+ if path != None:
+ return (name, path, True)
+ notice('Not changing base path for ', name);
+
+ return (None, None, None)
+
+def string_to_bytes(s):
+ if isinstance(s, str):
+ return s.encode('utf-8')
+ return s # E.g. None
+
+def make_dicts(tags):
+ global tags_dict, subst_dict
+
+ tags_dict = {}
+ subst_dict = {}
+ if not tags:
+ return
+
+ for tag in tags:
+ (name, path, subst) = split_key_value(tag)
+ if subst == None:
+ continue
+ # Translate a local absolute path to URI.
+ path = path.replace('\\', '/').replace(' ', '%20')
+ if path.startswith('/'):
+ path = 'file://' + path
+ path = re.sub(r'^([A-Za-z]:/)', r'file:///\1', path, count=1) # Windows: C:/path
+ if not path.endswith('/'):
+ path += '/'
+ if subst:
+ notice('Using base path ', path, ' for ', name)
+ subst_dict[string_to_bytes(name)] = string_to_bytes(path)
+ else:
+ notice('Using base path ', path, ' for tag file ', name)
+ tags_dict[string_to_bytes(name)] = string_to_bytes(path)
+
+def doc_install_funcargs(sources=[], target=None, book_base=None, tags=[],
+ mode=0o644, target_is_dir=True, expand_glob=False, verbose=False):
+ '''
+ Copy source files to target files or target directory.
+ '''
+ global g_verbose, perm_mode, g_book_base
+
+ g_verbose = verbose
+ perm_mode = mode
+ make_dicts(tags)
+ g_book_base = string_to_bytes(book_base)
+
+ if not target:
+ error('Target file or directory required.')
+ if book_base:
+ notice('Using base path ', book_base, ' for Devhelp book')
+
+ if not target_is_dir:
+ if expand_glob:
+ error('Filename globbing requires target directory.')
+ if len(sources) != 1:
+ error('Only one source file allowed when target is a filename.')
+
+ install_file(sources[0], target)
+ return 0
+
+ if expand_glob:
+ expanded_sources = []
+ for source in sources:
+ expanded_sources += glob.glob(source)
+ sources = expanded_sources
+
+ basename_set = set()
+ for source in sources:
+ basename = os.path.basename(source)
+
+ # If there are multiple files with the same base name in the list, only
+ # the first one will be installed. This behavior makes it very easy to
+ # implement a VPATH search for each individual file.
+ if basename not in basename_set:
+ basename_set.add(basename)
+ out_name = os.path.join(target, basename)
+ install_file(source, out_name)
+ return 0
+
+def doc_install_cmdargs(args=None):
+ '''
+ Parse command line parameters, or a sequence of strings equal to
+ command line parameters. Then copy source files to target file or
+ target directory.
+ '''
+ import argparse
+
+ parser = argparse.ArgumentParser(
+ formatter_class=argparse.RawTextHelpFormatter,
+ prog=os.path.basename(__file__),
+ usage='''
+ %(prog)s [OPTION]... [-T] SOURCE DEST
+ %(prog)s [OPTION]... SOURCE... DIRECTORY
+ %(prog)s [OPTION]... -t DIRECTORY SOURCE...''',
+ description='''
+ Copy SOURCE to DEST or multiple SOURCE files to the existing DIRECTORY,
+ while setting permission modes. For HTML files, translate references to
+ external documentation.'''
+ )
+ parser.add_argument('--book-base', dest='book_base', metavar='BASEPATH',
+ help='use reference BASEPATH for Devhelp book')
+ parser.add_argument('-l', '--tag-base', action='append', dest='tags', metavar='SUBST',
+ help='''TAGFILE@BASEPATH use BASEPATH for references from TAGFILE (Doxygen <= 1.8.15)
+s@BASEPUB@BASEPATH substitute BASEPATH for BASEPUB (Doxygen >= 1.8.16)'''
+ )
+ parser.add_argument('-m', '--mode', dest='mode', metavar='MODE', default='0o644',
+ help='override file permission MODE (octal)')
+
+ group = parser.add_mutually_exclusive_group()
+ group.add_argument('-t', '--target-directory', dest='target_dir', metavar='DIRECTORY',
+ help='copy all SOURCE arguments into DIRECTORY')
+ group.add_argument('-T', '--no-target-directory', action='store_false', dest='target_is_dir',
+ help='treat DEST as normal file')
+
+ parser.add_argument('--glob', action='store_true', dest='expand_glob',
+ help='expand SOURCE as filename glob pattern')
+ parser.add_argument('-v', '--verbose', action='store_true', dest='verbose',
+ help='enable informational messages')
+ parser.add_argument('source_dest', nargs='+',
+ help='''SOURCE DEST
+SOURCE... DIRECTORY
+SOURCE...'''
+ )
+ parsed_args = parser.parse_args(args)
+
+ if not parsed_args.target_is_dir:
+ if len(parsed_args.source_dest) != 2:
+ error('Source and destination filenames expected.')
+ sources = [parsed_args.source_dest[0]]
+ target = parsed_args.source_dest[1]
+ else:
+ target = parsed_args.target_dir
+ if not target:
+ if len(parsed_args.source_dest) < 2:
+ error('At least one source file and destination directory expected.')
+ target = parsed_args.source_dest[-1]
+ sources = parsed_args.source_dest[0:-1]
+ else:
+ sources = parsed_args.source_dest
+
+ return doc_install_funcargs(
+ sources=sources,
+ target=target,
+ book_base=parsed_args.book_base,
+ tags=parsed_args.tags,
+ mode=int(parsed_args.mode, base=8),
+ target_is_dir=parsed_args.target_is_dir,
+ expand_glob=parsed_args.expand_glob,
+ verbose=parsed_args.verbose
+ )
+
+# ----- Main -----
+if __name__ == '__main__':
+ sys.exit(doc_install_cmdargs())
--- /dev/null
+#!/usr/bin/env python3
+
+# doc_postprocess.py [-h|--help] <pattern>...
+
+# Post-process the Doxygen-generated HTML files matching pattern.
+
+import os
+import sys
+import re
+import glob
+
+# Substitutions with regular expressions are somewhat slow in Python 3.9.5.
+# Use str.replace() rather than re.sub() where possible.
+
+# [search string, compiled regular expression or None, substitution string, count]
+class_el_patterns = [
+ # return value
+ [ ' & ', re.compile(r' & *'), '& ', 1],
+ [ ' * ', re.compile(r' \* *'), '* ', 1],
+ # parameters
+ [ ' &', None, '&', 0],
+ [ '&', re.compile(r'&\b'), '& ', 0],
+ [ ' *', None, '*', 0],
+ [ '*', re.compile(r'\*\b'), '* ', 0],
+ # templates
+ [ 'template<', re.compile(r'\btemplate<'), 'template <', 1]
+]
+
+class_md_patterns = [
+ # left parenthesis
+ [ '( ', re.compile(r'\( *'), '(', 1],
+ # return value
+ [ ' & ', None, '& ', 0],
+ [ ' * ', None, '* ', 0],
+ # parameters
+ [ ' & ', re.compile(r' & *'), '& ', 0],
+ [ ' * ', re.compile(r' \* *'), '* ', 0],
+ # templates
+ [ 'template<', re.compile(r'\btemplate<'), 'template <', 1]
+]
+
+else_patterns = [
+ # template decls
+ [ 'template<', re.compile(r'^(<h\d>|)template<'), '\\1template <', 1]
+]
+
+all_lines_patterns = [
+ # For some reason, some versions of Doxygen output the full path to
+ # referenced tag files. This is bad since it breaks doc_install.py,
+ # and also because it leaks local path names into source tarballs.
+ # Thus, strip the directory prefix here.
+ [ ' doxygen="', re.compile(r' doxygen="[^":]*/([^":]+\.tag):'), ' doxygen="\\1:', 0],
+
+ [ '©', None, '©', 0],
+ [ '—', None, '—', 0],
+ [ '–', None, '–', 0],
+ [ ' ', re.compile(r' * *'), ' ', 0]
+]
+
+def doc_postprocess(patterns):
+ if not (isinstance(patterns, list) or isinstance(patterns, tuple)):
+ patterns = [] if patterns == None else [patterns]
+
+ filepaths = []
+ for pattern in patterns:
+ filepaths += glob.glob(pattern)
+
+ for filepath in filepaths:
+ # Assume that the file is UTF-8 encoded.
+ # If illegal UTF-8 bytes in the range 0x80..0xff are encountered, they are
+ # replaced by Unicode Private Use characters in the range 0xdc80..0xdcff
+ # and restored to their original values when the file is rewritten.
+ with open(filepath, mode='r', encoding='utf-8', errors='surrogateescape') as file:
+ # Read the whole file into a buffer, a list with one line per element.
+ buf = file.readlines()
+
+ for line_number in range(len(buf)):
+ line = buf[line_number]
+
+ # Substitute
+ if '<a class="el"' in line:
+ for subst in class_el_patterns:
+ if subst[0] in line:
+ if subst[1]:
+ line = subst[1].sub(subst[2], line, count=subst[3])
+ else:
+ line = line.replace(subst[0], subst[2], subst[3])
+
+ elif ('<td class="md"' in line) or ('<td class="mdname"' in line):
+ for subst in class_md_patterns:
+ if subst[0] in line:
+ if subst[1]:
+ line = subst[1].sub(subst[2], line, count=subst[3])
+ else:
+ line = line.replace(subst[0], subst[2], subst[3])
+
+ else:
+ for subst in else_patterns:
+ if subst[0] in line:
+ if subst[1]:
+ line = subst[1].sub(subst[2], line, count=subst[3])
+ else:
+ line = line.replace(subst[0], subst[2], subst[3])
+
+ for subst in all_lines_patterns:
+ if subst[0] in line:
+ if subst[1]:
+ line = subst[1].sub(subst[2], line, count=subst[3])
+ else:
+ line = line.replace(subst[0], subst[2], subst[3])
+
+ buf[line_number] = line
+
+ with open(filepath, mode='w', encoding='utf-8', errors='surrogateescape') as file:
+ # Write the whole buffer back into the file.
+ file.writelines(buf)
+
+ return 0
+
+# ----- Main -----
+if __name__ == '__main__':
+ import argparse
+
+ parser = argparse.ArgumentParser(
+ description='Post-process the Doxygen-generated HTML files matching pattern.')
+ parser.add_argument('patterns', nargs='*', metavar='pattern', help='filename pattern')
+ args = parser.parse_args()
+ print(args.patterns)
+
+ sys.exit(doc_postprocess(args.patterns))
--- /dev/null
+/* GNOME C++ bindings Doxygen style */
+
+/* Use in Doxyfile.in
+ * HTML_EXTRA_STYLESHEET = "$(MMDOCTOOLDIR)/doxygen-extra.css"
+ */
+
+html, body {
+ background: #FFFFFF;
+ color: #222222;
+ margin: 0;
+}
+
+body {
+ font: normal 90%/150% sans-serif;
+ padding: 1.5em;
+ min-width: 28em;
+}
+
+table {
+ font-size: inherit;
+}
+
+img {
+ border-style: none;
+}
+
+address img {
+ vertical-align: middle;
+}
+
+h1 {
+ font-size: 150%;
+ line-height: 120%;
+ text-align: center;
+}
+
+h2 {
+ font-size: 120%;
+}
+
+h3 {
+ font-size: 100%;
+}
+
+h1 + h3 {
+ text-align: center;
+}
+
+.navpath {
+ display: none;
+}
+
+caption {
+ font-weight: bold;
+}
+
+p, dl {
+ margin: 0.75em 0;
+}
+
+.center {
+ text-align: center;
+}
+
+div.qindex {
+ width: 100%;
+ line-height: 140%;
+ background-color: #E8EEF2;
+ border: 1px solid #84B0C7;
+ text-align: center;
+ margin: 0.2em;
+ padding: 0.2em;
+}
+
+a {
+ color: #153788;
+ font-weight: normal;
+ text-decoration: none;
+}
+
+.contents a:visited {
+ color: #1B77C5;
+}
+
+a:hover {
+ text-decoration: underline;
+}
+
+a.el, a.qindex {
+ font-weight: bold;
+}
+
+dl.el {
+ margin-left: -1.5em;
+}
+
+code, .fragment {
+ font-family: monospace, fixed;
+}
+
+pre.fragment, div.fragment {
+ background-color: #EEEEFF;
+ border: 1px solid #AAAAFF;
+ padding: 0.5em;
+ margin: 0.375em 0.75em 0.375em 0.2em;
+}
+
+div.fragment > pre.fragment {
+ border-style: none;
+ padding: 0;
+ margin: 0;
+}
+
+div.line {
+ white-space: pre;
+}
+
+div.ah {
+ background-color: #000000;
+ color: #FFFFFF;
+ font-weight: bold;
+ margin: 0.2em 0;
+}
+
+.indexkey, .indexvalue {
+ background-color: #E8EEF2;
+ border: 1px solid #CCCCCC;
+ margin: 0.2em 0;
+ padding: 0.2em 0.75em;
+}
+
+.indexkey {
+ font-weight: bold;
+}
+.memlist {
+ background-color: #F0F0F0;
+}
+
+span.keyword {
+ color: #008000;
+}
+
+span.keywordtype {
+ color: #604020;
+}
+
+span.keywordflow {
+ color: #E08000;
+}
+
+span.comment {
+ color: #800000;
+}
+
+span.preprocessor {
+ color: #806020;
+}
+
+span.stringliteral {
+ color: #002080;
+}
+
+span.charliteral {
+ color: #008080;
+}
+
+.tiny {
+ font-size: 80%;
+}
+
+hr {
+ height: 0;
+ border: none;
+ border-top: 1px solid #666666;
+}
+
+.mdescLeft, .mdescRight, .memItemLeft, .memItemRight,
+.memTemplItemLeft, .memTemplItemRight, .memTemplParams {
+ background-color: #FAFAFA;
+ border: none;
+ margin: 0.375em;
+ padding: 0.125em 0 0 0.75em;
+}
+
+.mdescLeft, .mdescRight {
+ padding: 0 0.75em 0.375em;
+ color: #555555;
+}
+
+.memItemLeft, .memItemRight, .memTemplParams {
+ border-top: 1px solid #CCCCCC;
+}
+
+.memTemplParams {
+ color: #606060;
+}
+
+.memtemplate {
+ color: #606060;
+ font-size: 90%;
+ font-weight: normal;
+ margin-left: 0.2em;
+}
+
+.memnav {
+ background-color: #E8EEF2;
+ border: 1px solid #84B0C7;
+ text-align: center;
+ margin: 0.2em 1em 0.2em 0;
+ padding: 0.2em;
+}
+
+.memitem {
+ margin: 0.5em 0;
+ padding: 0;
+}
+
+.memname {
+ white-space: nowrap;
+ font-weight: bold;
+ line-height: 120%;
+}
+
+.memproto, .memdoc {
+ border: 1px solid #84B0C7;
+}
+
+.memproto {
+ padding: 0;
+ background-color: #D5E1E8;
+ font-weight: bold;
+ -webkit-border-top-left-radius: 1ex;
+ -webkit-border-top-right-radius: 1ex;
+ -moz-border-radius-topleft: 1ex;
+ -moz-border-radius-topright: 1ex;
+}
+
+.memdoc {
+ padding: 0.2em 0.5em;
+ background-color: #EEF3F5;
+ border-top-width: 0;
+ -webkit-border-bottom-left-radius: 1ex;
+ -webkit-border-bottom-right-radius: 1ex;
+ -moz-border-radius-bottomleft: 1ex;
+ -moz-border-radius-bottomright: 1ex;
+}
+
+.paramkey {
+ text-align: right;
+}
+
+.paramtype {
+ white-space: nowrap;
+}
+
+.paramname {
+ color: #602020;
+ white-space: nowrap;
+}
+
+.paramname em {
+ font-style: normal;
+}
--- /dev/null
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<title>Chapter 4. Advanced topics</title>
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot">
+<link rel="home" href="index.html" title="libsigc++">
+<link rel="up" href="index.html" title="libsigc++">
+<link rel="prev" href="sect-return-values.html" title="What about return values?">
+<link rel="next" href="sect-retyping.html" title="Retyping">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="navheader">
+<table width="100%" summary="Navigation header">
+<tr><th colspan="3" align="center">Chapter 4. Advanced topics</th></tr>
+<tr>
+<td width="20%" align="left">
+<a accesskey="p" href="sect-return-values.html">Prev</a>Â </td>
+<th width="60%" align="center">Â </th>
+<td width="20%" align="right">Â <a accesskey="n" href="sect-retyping.html">Next</a>
+</td>
+</tr>
+</table>
+<hr>
+</div>
+<div class="chapter">
+<div class="titlepage"><div><div><h1 class="title">
+<a name="chapter-advanced"></a>Chapter 4. Advanced topics</h1></div></div></div>
+<div class="toc">
+<p><b>Table of Contents</b></p>
+<ul class="toc">
+<li><span class="section"><a href="chapter-advanced.html#sect-rebinding">Rebinding</a></span></li>
+<li><span class="section"><a href="sect-retyping.html">Retyping</a></span></li>
+</ul>
+</div>
+
+
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="sect-rebinding"></a>Rebinding</h2></div></div></div>
+
+
+ <p>Suppose you already have a function that you want to be called when a
+ signal is emitted, but it takes the wrong argument types. For example, lets try
+ to attach the <code class="literal">warn_people(std::string)</code> function to the detected signal
+ from the first example, which didn't supply a location string.</p>
+
+ <p>Just trying to connect it with:</p>
+
+<pre class="programlisting">
+myaliendetector.signal_detected.connect(sigc::ptr_fun(warn_people));
+</pre>
+
+ <p>results in a compile-time error, because the types don't match. This is good!
+ This is typesafety at work. In the C way of doing things, this would have just
+ died at runtime after trying to print a random bit of memory as the location -
+ ick!</p>
+
+ <p>We have to make up a location string, and bind it to the function, so that
+ when signal_detected is emitted with no arguments, something adds it in before
+ <code class="literal">warn_people</code> is actually called.</p>
+ <p>We could write it ourselves - it's not hard:</p>
+
+<pre class="programlisting">
+void warn_people_wrapper() // note this is the signature that 'signal_detected' expects
+{
+ warn_people("the carpark");
+}
+</pre>
+
+ <p>but after our first million or so we might start looking for a better way. As
+ it happens, libsigc++ has one.</p>
+
+<pre class="programlisting">
+sigc::bind(slot, arg);
+</pre>
+
+ <p>binds arg as the argument to slot, and returns a new slot of the same return
+ type, but with one fewer arguments.</p>
+
+ <p>Now we can write:</p>
+<pre class="programlisting">
+myaliendetector.signal_detected.connect(sigc::bind( sigc::ptr_fun(warn_people), "the carpark" ) );
+</pre>
+
+ <p>If the input slot has multiple args, the rightmost one is bound.</p>
+
+ <p>The return type can also be bound with <code class="literal">sigc::bind_return(slot, returnvalue);</code> though
+ this is not so commonly useful.</p>
+
+ <p>So if we can attach the new <code class="literal">warn_people()</code> to the old detector, can we attach
+ the old <code class="literal">warn_people</code> (the one that didn't take an argument) to the new detector?</p>
+
+ <p>Of course, we just need to hide the extra argument. This can be done with
+ <code class="literal">sigc::hide</code>, eg.</p>
+
+<pre class="programlisting">
+myaliendetector.signal_detected.connect( sigc::hide<std::string>( sigc::ptr_fun(warn_people) ) );
+</pre>
+
+ <p>The template arguments are the types to hide (from the right only - you can't
+ hide the first argument of 3, for example, only the last).</p>
+
+ <p><code class="literal">sigc::hide_return</code> effectively makes the return type void.</p>
+</div>
+
+
+</div>
+<div class="navfooter">
+<hr>
+<table width="100%" summary="Navigation footer">
+<tr>
+<td width="40%" align="left">
+<a accesskey="p" href="sect-return-values.html">Prev</a>Â </td>
+<td width="20%" align="center">Â </td>
+<td width="40%" align="right">Â <a accesskey="n" href="sect-retyping.html">Next</a>
+</td>
+</tr>
+<tr>
+<td width="40%" align="left" valign="top">What about return values? </td>
+<td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td>
+<td width="40%" align="right" valign="top">Â Retyping</td>
+</tr>
+</table>
+</div>
+</body>
+</html>
--- /dev/null
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<title>Chapter 2. Connecting your code to signals</title>
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot">
+<link rel="home" href="index.html" title="libsigc++">
+<link rel="up" href="index.html" title="libsigc++">
+<link rel="prev" href="chapter-introduction.html" title="Chapter 1. Introduction">
+<link rel="next" href="sect-using-mem-func.html" title="Using a member function">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="navheader">
+<table width="100%" summary="Navigation header">
+<tr><th colspan="3" align="center">Chapter 2. Connecting your code to signals</th></tr>
+<tr>
+<td width="20%" align="left">
+<a accesskey="p" href="chapter-introduction.html">Prev</a>Â </td>
+<th width="60%" align="center">Â </th>
+<td width="20%" align="right">Â <a accesskey="n" href="sect-using-mem-func.html">Next</a>
+</td>
+</tr>
+</table>
+<hr>
+</div>
+<div class="chapter">
+<div class="titlepage"><div><div><h1 class="title">
+<a name="chapter-connecting"></a>Chapter 2. Connecting your code to signals</h1></div></div></div>
+<div class="toc">
+<p><b>Table of Contents</b></p>
+<ul class="toc">
+<li><span class="section"><a href="chapter-connecting.html#sect-simple-ex">A simple example</a></span></li>
+<li><span class="section"><a href="sect-using-mem-func.html">Using a member function</a></span></li>
+<li><span class="section"><a href="sect-signals-with-pars.html">Signals with parameters</a></span></li>
+<li><span class="section"><a href="sect-disconnecting.html">Disconnecting</a></span></li>
+</ul>
+</div>
+
+
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="sect-simple-ex"></a>A simple example</h2></div></div></div>
+
+
+ <p>So to get some experience, lets look at a simple example...</p>
+
+ <p>Lets say you and I are writing an application which informs the user when
+ aliens land in the car park. To keep the design nice and clean, and allow for
+ maximum portability to different interfaces, we decide to use libsigc++ to
+ split the project in two parts.</p>
+
+ <p>I will write the <code class="literal">AlienDetector</code> class, and you will write the code to inform
+ the user. (Well, OK, I'll write both, but we're pretending, remember?)</p>
+
+ <p>Here's my class:</p>
+
+<pre class="programlisting">
+class AlienDetector
+{
+public:
+ AlienDetector();
+
+ void run();
+
+ sigc::signal<void()> signal_detected;
+};
+</pre>
+
+ <p>(I'll explain the type of signal_detected later.)</p>
+
+ <p>Here's your code that uses it:</p>
+
+<pre class="programlisting">
+void warn_people()
+{
+ std::cout << "There are aliens in the carpark!" << std::endl;
+}
+
+int main()
+{
+ AlienDetector mydetector;
+ mydetector.signal_detected.connect( sigc::ptr_fun(warn_people) );
+
+ mydetector.run();
+
+ return 0;
+}
+</pre>
+
+ <p>You can use a lambda expression instead of sigc::ptr_fun().</p>
+<pre class="programlisting">
+ mydetector.signal_detected.connect( [](){ warn_people(); } );
+</pre>
+
+ <p>Pretty simple really - you call the <code class="literal">connect()</code> method on the signal to
+ connect your function. <code class="literal">connect()</code> takes a <code class="literal">slot</code> parameter (remember slots
+ are capable of holding any type of callback), so you convert your
+ <code class="literal">warn_people()</code> function to a slot using the <code class="literal">slot()</code> function.</p>
+
+ <p>To compile this example, use:</p>
+ <pre class="programlisting">g++ example1.cc -o example1 `pkg-config --cflags --libs sigc++-2.0`</pre>
+ <p>Note that those `` characters are backticks, not single quotes. Run it with</p>
+ <pre class="programlisting">./example1</pre>
+ <p>(Try not to panic when the aliens land!)</p>
+
+</div>
+
+
+
+
+
+
+</div>
+<div class="navfooter">
+<hr>
+<table width="100%" summary="Navigation footer">
+<tr>
+<td width="40%" align="left">
+<a accesskey="p" href="chapter-introduction.html">Prev</a>Â </td>
+<td width="20%" align="center">Â </td>
+<td width="40%" align="right">Â <a accesskey="n" href="sect-using-mem-func.html">Next</a>
+</td>
+</tr>
+<tr>
+<td width="40%" align="left" valign="top">Chapter 1. Introduction </td>
+<td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td>
+<td width="40%" align="right" valign="top">Â Using a member function</td>
+</tr>
+</table>
+</div>
+</body>
+</html>
--- /dev/null
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<title>Chapter 1. Introduction</title>
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot">
+<link rel="home" href="index.html" title="libsigc++">
+<link rel="up" href="index.html" title="libsigc++">
+<link rel="prev" href="index.html" title="libsigc++">
+<link rel="next" href="chapter-connecting.html" title="Chapter 2. Connecting your code to signals">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="navheader">
+<table width="100%" summary="Navigation header">
+<tr><th colspan="3" align="center">Chapter 1. Introduction</th></tr>
+<tr>
+<td width="20%" align="left">
+<a accesskey="p" href="index.html">Prev</a>Â </td>
+<th width="60%" align="center">Â </th>
+<td width="20%" align="right">Â <a accesskey="n" href="chapter-connecting.html">Next</a>
+</td>
+</tr>
+</table>
+<hr>
+</div>
+<div class="chapter">
+<div class="titlepage"><div><div><h1 class="title">
+<a name="chapter-introduction"></a>Chapter 1. Introduction</h1></div></div></div>
+<div class="toc">
+<p><b>Table of Contents</b></p>
+<ul class="toc"><li><span class="section"><a href="chapter-introduction.html#sect-motivation">Motivation</a></span></li></ul>
+</div>
+
+
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="sect-motivation"></a>Motivation</h2></div></div></div>
+
+
+ <p>There are many situations in which it is desirable to decouple code that
+ detects an event, and the code that deals with it. This is especially common in
+ GUI programming, where a toolkit might provide user interface elements such as
+ clickable buttons but, being a generic toolkit, doesn't know how an individual
+ application using that toolkit should handle the user clicking on it.</p>
+
+ <p>In C the callbacks are generally handled by the application calling a
+ 'register' function and passing a pointer to a function and a <code class="literal">void*</code>
+ argument, eg.</p>
+
+<pre class="programlisting">
+void clicked(void* data);
+
+button* okbutton = create_button("ok");
+static char somedata[] = "This is some data I want the clicked() function to have";
+
+register_click_handler(okbutton, clicked, somedata);
+</pre>
+
+ <p>When clicked, the toolkit will call <code class="literal">clicked()</code> with the data pointer passed
+ to the <code class="literal">register_click_handler()</code> function.</p>
+
+ <p>This works in C, but is not typesafe. There is no compile-time way of
+ ensuring that <code class="literal">clicked()</code> isn't expecting a struct of some sort instead of a
+ <code class="literal">char*</code>.</p>
+
+ <p>As C++ programmers, we want type safety. We also want to be able to use
+ things other than free-standing functions as callbacks.</p>
+
+ <p>libsigc++ provides the concept of a slot, which holds a reference to one of
+ the things that can be used as a callback:
+ </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem"><p>A free-standing function as in the example</p></li>
+<li class="listitem"><p>A functor object that defines operator() (a lambda expression
+ is such an object)</p></li>
+<li class="listitem"><p>A pointer-to-a-member-function and an instance of an object on which to invoke it (the
+ object should inherit from <code class="literal">sigc::trackable</code>)</p></li>
+</ul></div>
+
+ <p>All of which can take different numbers and types of arguments.</p>
+
+ <p>To make it easier to construct these, libsigc++ provides the sigc::ptr_fun() and sigc::mem_fun() functions, for creating slots from static functions and member functions, respectively. They return
+ a generic <code class="literal">signal::slot</code> type that can be invoked with <code class="literal">emit()</code> or <code class="literal">operator()</code>.</p>
+
+ <p>For the other side of the fence, libsigc++ provides <code class="literal">signal</code>s, to which the
+ client can attach <code class="literal">slot</code>s. When the <code class="literal">signal</code> is emitted, all the connected
+ <code class="literal">slot</code>s are called.</p>
+</div>
+</div>
+<div class="navfooter">
+<hr>
+<table width="100%" summary="Navigation footer">
+<tr>
+<td width="40%" align="left">
+<a accesskey="p" href="index.html">Prev</a>Â </td>
+<td width="20%" align="center">Â </td>
+<td width="40%" align="right">Â <a accesskey="n" href="chapter-connecting.html">Next</a>
+</td>
+</tr>
+<tr>
+<td width="40%" align="left" valign="top">libsigc++Â </td>
+<td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td>
+<td width="40%" align="right" valign="top"> Chapter 2. Connecting your code to signals</td>
+</tr>
+</table>
+</div>
+</body>
+</html>
--- /dev/null
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<title>Chapter 5. Reference</title>
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot">
+<link rel="home" href="index.html" title="libsigc++">
+<link rel="up" href="index.html" title="libsigc++">
+<link rel="prev" href="sect-retyping.html" title="Retyping">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="navheader">
+<table width="100%" summary="Navigation header">
+<tr><th colspan="3" align="center">Chapter 5. Reference</th></tr>
+<tr>
+<td width="20%" align="left">
+<a accesskey="p" href="sect-retyping.html">Prev</a>Â </td>
+<th width="60%" align="center">Â </th>
+<td width="20%" align="right">Â </td>
+</tr>
+</table>
+<hr>
+</div>
+<div class="chapter">
+<div class="titlepage"><div><div><h1 class="title">
+<a name="chapter-reference"></a>Chapter 5. Reference</h1></div></div></div>
+
+
+ <p>See the reference documentation <a class="ulink" href="http://library.gnome.org/devel/libsigc++/2.10/" target="_top">online</a></p>
+</div>
+<div class="navfooter">
+<hr>
+<table width="100%" summary="Navigation footer">
+<tr>
+<td width="40%" align="left">
+<a accesskey="p" href="sect-retyping.html">Prev</a>Â </td>
+<td width="20%" align="center">Â </td>
+<td width="40%" align="right">Â </td>
+</tr>
+<tr>
+<td width="40%" align="left" valign="top">Retyping </td>
+<td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td>
+<td width="40%" align="right" valign="top">Â </td>
+</tr>
+</table>
+</div>
+</body>
+</html>
--- /dev/null
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<title>Chapter 3. Writing your own signals</title>
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot">
+<link rel="home" href="index.html" title="libsigc++">
+<link rel="up" href="index.html" title="libsigc++">
+<link rel="prev" href="sect-disconnecting.html" title="Disconnecting">
+<link rel="next" href="sect-return-values.html" title="What about return values?">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="navheader">
+<table width="100%" summary="Navigation header">
+<tr><th colspan="3" align="center">Chapter 3. Writing your own signals</th></tr>
+<tr>
+<td width="20%" align="left">
+<a accesskey="p" href="sect-disconnecting.html">Prev</a>Â </td>
+<th width="60%" align="center">Â </th>
+<td width="20%" align="right">Â <a accesskey="n" href="sect-return-values.html">Next</a>
+</td>
+</tr>
+</table>
+<hr>
+</div>
+<div class="chapter">
+<div class="titlepage"><div><div><h1 class="title">
+<a name="chapter-writing"></a>Chapter 3. Writing your own signals</h1></div></div></div>
+<div class="toc">
+<p><b>Table of Contents</b></p>
+<ul class="toc">
+<li><span class="section"><a href="chapter-writing.html#sect-quick-recap">Quick recap</a></span></li>
+<li><span class="section"><a href="sect-return-values.html">What about return values?</a></span></li>
+</ul>
+</div>
+
+
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="sect-quick-recap"></a>Quick recap</h2></div></div></div>
+
+
+ <p>If all you want to do is use gtkmm, and connect your functionality to its
+ signals, you can probably stop reading here.</p>
+
+ <p>You might benefit from reading on anyway though, as this section is going to
+ be quite simple, and the 'Rebinding' technique from the next section is
+ occasionally useful.</p>
+
+ <p>We've already covered the way the types of signals are made up, but lets
+ recap:</p>
+
+ <p>A signal is an instance of a template, named <code class="literal">sigc::signal</code>.
+ The template arguments are the types,
+ in the order they appear in the function signature that can be connected to that
+ signal; that is the return type, then the argument types in parentheses.</p>
+
+ <p>To provide a signal for people to connect to, you must make available an
+ instance of that <code class="literal">sigc::signal</code>. In <code class="literal">AlienDetector</code> this was done
+ with a public data member. That's not considered good practice usually, so you
+ might want to consider making a member function that returns the signal by
+ reference. (This is what gtkmm does.)</p>
+
+ <p>Once you've done this, all you have to do is emit the signal when you're
+ ready. Look at the code for <code class="literal">AlienDetector::run()</code>:</p>
+
+<pre class="programlisting">
+void AlienDetector::run()
+{
+ sleep(3); // wait for aliens
+ signal_detected.emit(); // panic!
+}
+</pre>
+
+ <p>As a shortcut, <code class="literal">sigc::signal</code> defines <code class="literal">operator()</code> as a synonym for
+ <code class="literal">emit()</code>, so you could just write <code class="literal">signal_detected();</code> as in the second
+ example version:</p>
+
+<pre class="programlisting">
+void AlienDetector::run()
+{
+ sleep(3); // wait for aliens
+ signal_detected("the carpark"); // this is the std::string version, looks like
+ // they landed in the carpark after all.
+}
+</pre>
+</div>
+
+
+</div>
+<div class="navfooter">
+<hr>
+<table width="100%" summary="Navigation footer">
+<tr>
+<td width="40%" align="left">
+<a accesskey="p" href="sect-disconnecting.html">Prev</a>Â </td>
+<td width="20%" align="center">Â </td>
+<td width="40%" align="right">Â <a accesskey="n" href="sect-return-values.html">Next</a>
+</td>
+</tr>
+<tr>
+<td width="40%" align="left" valign="top">Disconnecting </td>
+<td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td>
+<td width="40%" align="right" valign="top">Â What about return values?</td>
+</tr>
+</table>
+</div>
+</body>
+</html>
--- /dev/null
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<title>libsigc++</title>
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot">
+<meta name="description" content="libsigc++ is a C++ template library implementing typesafe callbacks. This is an intro to libsigc++.">
+<link rel="home" href="index.html" title="libsigc++">
+<link rel="next" href="chapter-introduction.html" title="Chapter 1. Introduction">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="navheader">
+<table width="100%" summary="Navigation header">
+<tr><th colspan="3" align="center">libsigc++</th></tr>
+<tr>
+<td width="20%" align="left">Â </td>
+<th width="60%" align="center">Â </th>
+<td width="20%" align="right">Â <a accesskey="n" href="chapter-introduction.html">Next</a>
+</td>
+</tr>
+</table>
+<hr>
+</div>
+<div lang="en" class="book">
+<div class="titlepage">
+<div>
+<div><h1 class="title">
+<a name="index"></a>libsigc++</h1></div>
+<div><div class="author"><h3 class="author">
+<span class="firstname">Ainsley</span> <span class="surname">Pereira</span>
+</h3></div></div>
+<div><p class="pubdate">September 2002. Updated January 2004 by Murray Cumming</p></div>
+<div><div class="abstract">
+<p class="title"><b>Abstract</b></p>
+ <p>libsigc++ is a C++ template library implementing typesafe callbacks. This is an intro to libsigc++.</p>
+ </div></div>
+</div>
+<hr>
+</div>
+<div class="toc">
+<p><b>Table of Contents</b></p>
+<ul class="toc">
+<li>
+<span class="chapter"><a href="chapter-introduction.html">1. Introduction</a></span><ul><li><span class="section"><a href="chapter-introduction.html#sect-motivation">Motivation</a></span></li></ul>
+</li>
+<li>
+<span class="chapter"><a href="chapter-connecting.html">2. Connecting your code to signals</a></span><ul>
+<li><span class="section"><a href="chapter-connecting.html#sect-simple-ex">A simple example</a></span></li>
+<li><span class="section"><a href="sect-using-mem-func.html">Using a member function</a></span></li>
+<li><span class="section"><a href="sect-signals-with-pars.html">Signals with parameters</a></span></li>
+<li><span class="section"><a href="sect-disconnecting.html">Disconnecting</a></span></li>
+</ul>
+</li>
+<li>
+<span class="chapter"><a href="chapter-writing.html">3. Writing your own signals</a></span><ul>
+<li><span class="section"><a href="chapter-writing.html#sect-quick-recap">Quick recap</a></span></li>
+<li><span class="section"><a href="sect-return-values.html">What about return values?</a></span></li>
+</ul>
+</li>
+<li>
+<span class="chapter"><a href="chapter-advanced.html">4. Advanced topics</a></span><ul>
+<li><span class="section"><a href="chapter-advanced.html#sect-rebinding">Rebinding</a></span></li>
+<li><span class="section"><a href="sect-retyping.html">Retyping</a></span></li>
+</ul>
+</li>
+<li><span class="chapter"><a href="chapter-reference.html">5. Reference</a></span></li>
+</ul>
+</div>
+
+
+
+
+
+
+
+
+
+
+
+
+</div>
+<div class="navfooter">
+<hr>
+<table width="100%" summary="Navigation footer">
+<tr>
+<td width="40%" align="left">Â </td>
+<td width="20%" align="center">Â </td>
+<td width="40%" align="right">Â <a accesskey="n" href="chapter-introduction.html">Next</a>
+</td>
+</tr>
+<tr>
+<td width="40%" align="left" valign="top">Â </td>
+<td width="20%" align="center">Â </td>
+<td width="40%" align="right" valign="top"> Chapter 1. Introduction</td>
+</tr>
+</table>
+</div>
+</body>
+</html>
--- /dev/null
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<title>Disconnecting</title>
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot">
+<link rel="home" href="index.html" title="libsigc++">
+<link rel="up" href="chapter-connecting.html" title="Chapter 2. Connecting your code to signals">
+<link rel="prev" href="sect-signals-with-pars.html" title="Signals with parameters">
+<link rel="next" href="chapter-writing.html" title="Chapter 3. Writing your own signals">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="navheader">
+<table width="100%" summary="Navigation header">
+<tr><th colspan="3" align="center">Disconnecting</th></tr>
+<tr>
+<td width="20%" align="left">
+<a accesskey="p" href="sect-signals-with-pars.html">Prev</a>Â </td>
+<th width="60%" align="center">Chapter 2. Connecting your code to signals</th>
+<td width="20%" align="right">Â <a accesskey="n" href="chapter-writing.html">Next</a>
+</td>
+</tr>
+</table>
+<hr>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="sect-disconnecting"></a>Disconnecting</h2></div></div></div>
+
+
+ <p>If you decide you no longer want your code to be called whenever a signal is
+ emitted, you must remember the return value of <code class="literal">connect()</code>, which we've been
+ ignoring until now.</p>
+
+ <p><code class="literal">connect()</code> returns a <code class="literal">sigc::connection</code> object, which has a <code class="literal">disconnect()</code> member method. This does just what you think it does.</p>
+
+</div>
+<div class="navfooter">
+<hr>
+<table width="100%" summary="Navigation footer">
+<tr>
+<td width="40%" align="left">
+<a accesskey="p" href="sect-signals-with-pars.html">Prev</a>Â </td>
+<td width="20%" align="center"><a accesskey="u" href="chapter-connecting.html">Up</a></td>
+<td width="40%" align="right">Â <a accesskey="n" href="chapter-writing.html">Next</a>
+</td>
+</tr>
+<tr>
+<td width="40%" align="left" valign="top">Signals with parameters </td>
+<td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td>
+<td width="40%" align="right" valign="top"> Chapter 3. Writing your own signals</td>
+</tr>
+</table>
+</div>
+</body>
+</html>
--- /dev/null
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<title>What about return values?</title>
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot">
+<link rel="home" href="index.html" title="libsigc++">
+<link rel="up" href="chapter-writing.html" title="Chapter 3. Writing your own signals">
+<link rel="prev" href="chapter-writing.html" title="Chapter 3. Writing your own signals">
+<link rel="next" href="chapter-advanced.html" title="Chapter 4. Advanced topics">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="navheader">
+<table width="100%" summary="Navigation header">
+<tr><th colspan="3" align="center">What about return values?</th></tr>
+<tr>
+<td width="20%" align="left">
+<a accesskey="p" href="chapter-writing.html">Prev</a>Â </td>
+<th width="60%" align="center">Chapter 3. Writing your own signals</th>
+<td width="20%" align="right">Â <a accesskey="n" href="chapter-advanced.html">Next</a>
+</td>
+</tr>
+</table>
+<hr>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="sect-return-values"></a>What about return values?</h2></div></div></div>
+
+
+ <p>If you only ever have one slot connected to a signal, or if you only care
+ about the return value of the last registered one, it's quite straightforward:</p>
+
+<pre class="programlisting">
+sigc::signal<int()> somesignal;
+int a_return_value;
+
+a_return_value = somesignal.emit();
+</pre>
+</div>
+<div class="navfooter">
+<hr>
+<table width="100%" summary="Navigation footer">
+<tr>
+<td width="40%" align="left">
+<a accesskey="p" href="chapter-writing.html">Prev</a>Â </td>
+<td width="20%" align="center"><a accesskey="u" href="chapter-writing.html">Up</a></td>
+<td width="40%" align="right">Â <a accesskey="n" href="chapter-advanced.html">Next</a>
+</td>
+</tr>
+<tr>
+<td width="40%" align="left" valign="top">Chapter 3. Writing your own signals </td>
+<td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td>
+<td width="40%" align="right" valign="top"> Chapter 4. Advanced topics</td>
+</tr>
+</table>
+</div>
+</body>
+</html>
--- /dev/null
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<title>Retyping</title>
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot">
+<link rel="home" href="index.html" title="libsigc++">
+<link rel="up" href="chapter-advanced.html" title="Chapter 4. Advanced topics">
+<link rel="prev" href="chapter-advanced.html" title="Chapter 4. Advanced topics">
+<link rel="next" href="chapter-reference.html" title="Chapter 5. Reference">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="navheader">
+<table width="100%" summary="Navigation header">
+<tr><th colspan="3" align="center">Retyping</th></tr>
+<tr>
+<td width="20%" align="left">
+<a accesskey="p" href="chapter-advanced.html">Prev</a>Â </td>
+<th width="60%" align="center">Chapter 4. Advanced topics</th>
+<td width="20%" align="right">Â <a accesskey="n" href="chapter-reference.html">Next</a>
+</td>
+</tr>
+</table>
+<hr>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="sect-retyping"></a>Retyping</h2></div></div></div>
+
+
+ <p>A similar topic is retyping. Perhaps you have a signal that takes an <code class="literal">int</code>, but
+ you want to connect a function that takes a <code class="literal">double</code>.</p>
+
+ <p>This can be achieved with the <code class="literal">sigc::retype()</code> template.
+ It takes a <code class="literal">sigc::slot</code>, and returns a <code class="literal">sigc::slot</code>. eg.</p>
+
+<pre class="programlisting">
+void dostuff(double foo)
+{
+}
+
+sigc::signal<void(int)> asignal;
+
+asignal.connect( sigc::retype( sigc::ptr_fun(&dostuff) ) );
+</pre>
+
+ <p>If you only want to change the return type, you can use <code class="literal">sigc::retype_return()</code>.
+ <code class="literal">retype_return()</code> needs one template argument, the new return type.</p>
+</div>
+<div class="navfooter">
+<hr>
+<table width="100%" summary="Navigation footer">
+<tr>
+<td width="40%" align="left">
+<a accesskey="p" href="chapter-advanced.html">Prev</a>Â </td>
+<td width="20%" align="center"><a accesskey="u" href="chapter-advanced.html">Up</a></td>
+<td width="40%" align="right">Â <a accesskey="n" href="chapter-reference.html">Next</a>
+</td>
+</tr>
+<tr>
+<td width="40%" align="left" valign="top">Chapter 4. Advanced topics </td>
+<td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td>
+<td width="40%" align="right" valign="top"> Chapter 5. Reference</td>
+</tr>
+</table>
+</div>
+</body>
+</html>
--- /dev/null
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<title>Signals with parameters</title>
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot">
+<link rel="home" href="index.html" title="libsigc++">
+<link rel="up" href="chapter-connecting.html" title="Chapter 2. Connecting your code to signals">
+<link rel="prev" href="sect-using-mem-func.html" title="Using a member function">
+<link rel="next" href="sect-disconnecting.html" title="Disconnecting">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="navheader">
+<table width="100%" summary="Navigation header">
+<tr><th colspan="3" align="center">Signals with parameters</th></tr>
+<tr>
+<td width="20%" align="left">
+<a accesskey="p" href="sect-using-mem-func.html">Prev</a>Â </td>
+<th width="60%" align="center">Chapter 2. Connecting your code to signals</th>
+<td width="20%" align="right">Â <a accesskey="n" href="sect-disconnecting.html">Next</a>
+</td>
+</tr>
+</table>
+<hr>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="sect-signals-with-pars"></a>Signals with parameters</h2></div></div></div>
+
+
+ <p>Functions taking no parameters and returning void are quite useful,
+ especially when they're members of classes that can store unlimited amounts of
+ safely typed data, but they're not sufficient for everything.</p>
+
+ <p>What if aliens don't land in the carpark, but somewhere else? Let's modify
+ the example so that the callback function takes a <code class="literal">std::string</code> with the location
+ in which aliens were detected.</p>
+
+ <p>I change my class to:</p>
+
+<pre class="programlisting">
+class AlienDetector
+{
+public:
+ AlienDetector();
+
+ void run();
+
+ sigc::signal<void(std::string)> signal_detected; // changed
+};
+</pre>
+
+ <p>The only line I had to change was the signal line (in <code class="literal">run()</code> I need to change
+ my code to supply the argument when I emit the signal too, but that's not shown
+ here).</p>
+
+ <p>The name of the type is '<code class="literal">sigc::signal</code>'.
+ The template parameters are the return type, then the argument types in parentheses.
+ (libsigc++2 also accepts a different syntax, with a comma between the return type
+ and the parameter types. That syntax is deprecated, though.)</p>
+
+ <p>The types in the function signature are in the same order as the template
+ parameters, eg:</p>
+
+<pre class="programlisting">
+sigc::signal<void(std::string)>
+ void function(std::string foo);
+</pre>
+
+ <p>So now you can update your alerter (for simplicity, lets go back to the
+ free-standing function version):</p>
+
+<pre class="programlisting">
+void warn_people(std::string where)
+{
+ std::cout << "There are aliens in " << where << "!" << std::endl;
+}
+
+int main()
+{
+ AlienDetector mydetector;
+ mydetector.signal_detected.connect( sigc::ptr_fun(warn_people) );
+
+ mydetector.run();
+
+ return 0;
+}
+</pre>
+
+ <p>Easy.</p>
+</div>
+<div class="navfooter">
+<hr>
+<table width="100%" summary="Navigation footer">
+<tr>
+<td width="40%" align="left">
+<a accesskey="p" href="sect-using-mem-func.html">Prev</a>Â </td>
+<td width="20%" align="center"><a accesskey="u" href="chapter-connecting.html">Up</a></td>
+<td width="40%" align="right">Â <a accesskey="n" href="sect-disconnecting.html">Next</a>
+</td>
+</tr>
+<tr>
+<td width="40%" align="left" valign="top">Using a member function </td>
+<td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td>
+<td width="40%" align="right" valign="top">Â Disconnecting</td>
+</tr>
+</table>
+</div>
+</body>
+</html>
--- /dev/null
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<title>Using a member function</title>
+<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot">
+<link rel="home" href="index.html" title="libsigc++">
+<link rel="up" href="chapter-connecting.html" title="Chapter 2. Connecting your code to signals">
+<link rel="prev" href="chapter-connecting.html" title="Chapter 2. Connecting your code to signals">
+<link rel="next" href="sect-signals-with-pars.html" title="Signals with parameters">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="navheader">
+<table width="100%" summary="Navigation header">
+<tr><th colspan="3" align="center">Using a member function</th></tr>
+<tr>
+<td width="20%" align="left">
+<a accesskey="p" href="chapter-connecting.html">Prev</a>Â </td>
+<th width="60%" align="center">Chapter 2. Connecting your code to signals</th>
+<td width="20%" align="right">Â <a accesskey="n" href="sect-signals-with-pars.html">Next</a>
+</td>
+</tr>
+</table>
+<hr>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="sect-using-mem-func"></a>Using a member function</h2></div></div></div>
+
+
+ <p>Suppose you found a more sophisticated alien alerter class on the web,
+ such as this:</p>
+
+<pre class="programlisting">
+class AlienAlerter : public sigc::trackable
+{
+public:
+ AlienAlerter(char const* servername);
+ void alert();
+private:
+ // ...
+};
+</pre>
+
+ <p>(Handily it derives from <code class="literal">sigc::trackable</code> already. This isn't quite so
+ unlikely as you might think; all appropriate bits of the popular gtkmm library do so,
+ for example.)</p>
+
+ <p>You could rewrite your code as follows:</p>
+
+<pre class="programlisting">
+int main()
+{
+ AlienDetector mydetector;
+ AlienAlerter myalerter("localhost"); // added
+ mydetector.signal_detected.connect( sigc::mem_fun(myalerter, &AlienAlerter::alert) ); // changed
+
+ mydetector.run();
+
+ return 0;
+}
+</pre>
+
+ <p>Note that only 2 lines are different - one to create an instance of the
+ class, and the line to connect the method to the signal.</p>
+
+ <p>This code is in example2.cc, which can be compiled in the same way as
+ example1.cc</p>
+
+ <p>It's possible to use a lambda expression instead of sigc::mem_fun(),
+ but it's not recommended, if the class derives from <code class="literal">sigc::trackable</code>.
+ With a lambda expression you would lose the automatic disconnection that the
+ combination of <code class="literal">sigc::trackable</code> and sigc::mem_fun()
+ offers.</p>
+</div>
+<div class="navfooter">
+<hr>
+<table width="100%" summary="Navigation footer">
+<tr>
+<td width="40%" align="left">
+<a accesskey="p" href="chapter-connecting.html">Prev</a>Â </td>
+<td width="20%" align="center"><a accesskey="u" href="chapter-connecting.html">Up</a></td>
+<td width="40%" align="right">Â <a accesskey="n" href="sect-signals-with-pars.html">Next</a>
+</td>
+</tr>
+<tr>
+<td width="40%" align="left" valign="top">Chapter 2. Connecting your code to signals </td>
+<td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td>
+<td width="40%" align="right" valign="top">Â Signals with parameters</td>
+</tr>
+</table>
+</div>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">Class List</div> </div>
+</div><!--header-->
+<div class="contents">
+<div class="textblock">Here are the classes, structs, unions and interfaces with brief descriptions:</div><div class="directory">
+<div class="levels">[detail level <span onclick="javascript:toggleLevel(1);">1</span><span onclick="javascript:toggleLevel(2);">2</span><span onclick="javascript:toggleLevel(3);">3</span>]</div><table class="directory">
+<tr id="row_0_" class="even"><td class="entry"><span style="width:0px;display:inline-block;"> </span><span id="arr_0_" class="arrow" onclick="toggleFolder('0_')">►</span><span class="icona"><span class="icon">N</span></span><a class="el" href="namespacesigc.html" target="_self">sigc</a></td><td class="desc">The libsigc++ namespace </td></tr>
+<tr id="row_0_0_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1adaptor__base.html" target="_self">adaptor_base</a></td><td class="desc">A hint to the compiler </td></tr>
+<tr id="row_0_1_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1adaptor__functor.html" target="_self">adaptor_functor</a></td><td class="desc">Converts an arbitrary functor into an adaptor type </td></tr>
+<tr id="row_0_2_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1adaptor__trait.html" target="_self">adaptor_trait</a></td><td class="desc">Trait that specifies what is the adaptor version of a functor type </td></tr>
+<tr id="row_0_3_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html" target="_self">adaptor_trait< T_functor, false ></a></td><td class="desc">Trait that specifies what is the adaptor version of a functor type </td></tr>
+<tr id="row_0_4_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html" target="_self">adaptor_trait< T_functor, true ></a></td><td class="desc">Trait that specifies what is the adaptor version of a functor type </td></tr>
+<tr id="row_0_5_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1adapts.html" target="_self">adapts</a></td><td class="desc">Base type for adaptors </td></tr>
+<tr id="row_0_6_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1bind__functor.html" target="_self">bind_functor</a></td><td class="desc">Adaptor that binds an argument to the wrapped functor </td></tr>
+<tr id="row_0_7_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a></td><td class="desc">Adaptor that binds an argument to the wrapped functor </td></tr>
+<tr id="row_0_8_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a></td><td class="desc">Adaptor that binds 1 argument(s) to the wrapped functor </td></tr>
+<tr id="row_0_9_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1bind__return__functor.html" target="_self">bind_return_functor</a></td><td class="desc">Adaptor that fixes the return value of the wrapped functor </td></tr>
+<tr id="row_0_10_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__argument.html" target="_self">bound_argument</a></td><td class="desc">A bound_argument<Foo> object stores a bound (for instance, with <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">sigc::bind()</a>, or <a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a" title="Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed funct...">sigc::bind_return()</a>) argument </td></tr>
+<tr id="row_0_11_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html" target="_self">bound_argument< const_reference_wrapper< T_wrapped > ></a></td><td class="desc">Bound_argument object for a bound argument that is passed by <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">bind()</a> or returned by <a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a" title="Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed funct...">bind_return()</a> by const reference, specialized for const reference_wrapper<> types </td></tr>
+<tr id="row_0_12_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html" target="_self">bound_argument< reference_wrapper< T_wrapped > ></a></td><td class="desc">Bound_argument object for a bound argument that is passed by <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">bind()</a> or returned by <a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a" title="Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed funct...">bind_return()</a> by reference, specialized for reference_wrapper<> types </td></tr>
+<tr id="row_0_13_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html" target="_self">bound_argument< std::reference_wrapper< T_wrapped > ></a></td><td class="desc">Bound_argument object for a bound argument that is passed by <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">bind()</a> or returned by <a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a" title="Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed funct...">bind_return()</a> by reference, specialized for std::reference_wrapper<> types </td></tr>
+<tr id="row_0_14_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__mem__functor0.html" target="_self">bound_const_mem_functor0</a></td><td class="desc">Bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance </td></tr>
+<tr id="row_0_15_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__mem__functor1.html" target="_self">bound_const_mem_functor1</a></td><td class="desc">Bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance </td></tr>
+<tr id="row_0_16_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__mem__functor2.html" target="_self">bound_const_mem_functor2</a></td><td class="desc">Bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance </td></tr>
+<tr id="row_0_17_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__mem__functor3.html" target="_self">bound_const_mem_functor3</a></td><td class="desc">Bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance </td></tr>
+<tr id="row_0_18_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__mem__functor4.html" target="_self">bound_const_mem_functor4</a></td><td class="desc">Bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance </td></tr>
+<tr id="row_0_19_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__mem__functor5.html" target="_self">bound_const_mem_functor5</a></td><td class="desc">Bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance </td></tr>
+<tr id="row_0_20_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__mem__functor6.html" target="_self">bound_const_mem_functor6</a></td><td class="desc">Bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance </td></tr>
+<tr id="row_0_21_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__mem__functor7.html" target="_self">bound_const_mem_functor7</a></td><td class="desc">Bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance </td></tr>
+<tr id="row_0_22_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html" target="_self">bound_const_volatile_mem_functor0</a></td><td class="desc">Bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object instance </td></tr>
+<tr id="row_0_23_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html" target="_self">bound_const_volatile_mem_functor1</a></td><td class="desc">Bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object instance </td></tr>
+<tr id="row_0_24_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html" target="_self">bound_const_volatile_mem_functor2</a></td><td class="desc">Bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object instance </td></tr>
+<tr id="row_0_25_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html" target="_self">bound_const_volatile_mem_functor3</a></td><td class="desc">Bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object instance </td></tr>
+<tr id="row_0_26_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html" target="_self">bound_const_volatile_mem_functor4</a></td><td class="desc">Bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object instance </td></tr>
+<tr id="row_0_27_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html" target="_self">bound_const_volatile_mem_functor5</a></td><td class="desc">Bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object instance </td></tr>
+<tr id="row_0_28_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html" target="_self">bound_const_volatile_mem_functor6</a></td><td class="desc">Bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object instance </td></tr>
+<tr id="row_0_29_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html" target="_self">bound_const_volatile_mem_functor7</a></td><td class="desc">Bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object instance </td></tr>
+<tr id="row_0_30_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__mem__functor0.html" target="_self">bound_mem_functor0</a></td><td class="desc">Bound_mem_functor0 encapsulates a method with 0 arguments and an object instance </td></tr>
+<tr id="row_0_31_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__mem__functor1.html" target="_self">bound_mem_functor1</a></td><td class="desc">Bound_mem_functor1 encapsulates a method with 1 arguments and an object instance </td></tr>
+<tr id="row_0_32_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__mem__functor2.html" target="_self">bound_mem_functor2</a></td><td class="desc">Bound_mem_functor2 encapsulates a method with 2 arguments and an object instance </td></tr>
+<tr id="row_0_33_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__mem__functor3.html" target="_self">bound_mem_functor3</a></td><td class="desc">Bound_mem_functor3 encapsulates a method with 3 arguments and an object instance </td></tr>
+<tr id="row_0_34_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__mem__functor4.html" target="_self">bound_mem_functor4</a></td><td class="desc">Bound_mem_functor4 encapsulates a method with 4 arguments and an object instance </td></tr>
+<tr id="row_0_35_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__mem__functor5.html" target="_self">bound_mem_functor5</a></td><td class="desc">Bound_mem_functor5 encapsulates a method with 5 arguments and an object instance </td></tr>
+<tr id="row_0_36_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__mem__functor6.html" target="_self">bound_mem_functor6</a></td><td class="desc">Bound_mem_functor6 encapsulates a method with 6 arguments and an object instance </td></tr>
+<tr id="row_0_37_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__mem__functor7.html" target="_self">bound_mem_functor7</a></td><td class="desc">Bound_mem_functor7 encapsulates a method with 7 arguments and an object instance </td></tr>
+<tr id="row_0_38_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html" target="_self">bound_volatile_mem_functor0</a></td><td class="desc">Bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance </td></tr>
+<tr id="row_0_39_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html" target="_self">bound_volatile_mem_functor1</a></td><td class="desc">Bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance </td></tr>
+<tr id="row_0_40_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html" target="_self">bound_volatile_mem_functor2</a></td><td class="desc">Bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance </td></tr>
+<tr id="row_0_41_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html" target="_self">bound_volatile_mem_functor3</a></td><td class="desc">Bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance </td></tr>
+<tr id="row_0_42_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html" target="_self">bound_volatile_mem_functor4</a></td><td class="desc">Bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance </td></tr>
+<tr id="row_0_43_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html" target="_self">bound_volatile_mem_functor5</a></td><td class="desc">Bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance </td></tr>
+<tr id="row_0_44_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html" target="_self">bound_volatile_mem_functor6</a></td><td class="desc">Bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance </td></tr>
+<tr id="row_0_45_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html" target="_self">bound_volatile_mem_functor7</a></td><td class="desc">Bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance </td></tr>
+<tr id="row_0_46_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1can__deduce__result__type__with__decltype.html" target="_self">can_deduce_result_type_with_decltype</a></td><td class="desc">Helper class, to determine if decltype() can deduce the result type of a functor </td></tr>
+<tr id="row_0_47_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1compose1__functor.html" target="_self">compose1_functor</a></td><td class="desc">Adaptor that combines two functors </td></tr>
+<tr id="row_0_48_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1compose2__functor.html" target="_self">compose2_functor</a></td><td class="desc">Adaptor that combines three functors </td></tr>
+<tr id="row_0_49_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1connection.html" target="_self">connection</a></td><td class="desc">Convinience class for safe disconnection </td></tr>
+<tr id="row_0_50_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__limit__reference.html" target="_self">const_limit_reference</a></td><td class="desc">A const_limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>, then <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each<>()</a> will "limit" itself to the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference instead of the derived reference </td></tr>
+<tr id="row_0_51_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html" target="_self">const_limit_reference< T_type, true ></a></td><td class="desc">Const_limit_reference object for a class that derives from trackable </td></tr>
+<tr id="row_0_52_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__mem__functor0.html" target="_self">const_mem_functor0</a></td><td class="desc">Const_mem_functor0 wraps const methods with 0 argument(s) </td></tr>
+<tr id="row_0_53_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__mem__functor1.html" target="_self">const_mem_functor1</a></td><td class="desc">Const_mem_functor1 wraps const methods with 1 argument(s) </td></tr>
+<tr id="row_0_54_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__mem__functor2.html" target="_self">const_mem_functor2</a></td><td class="desc">Const_mem_functor2 wraps const methods with 2 argument(s) </td></tr>
+<tr id="row_0_55_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__mem__functor3.html" target="_self">const_mem_functor3</a></td><td class="desc">Const_mem_functor3 wraps const methods with 3 argument(s) </td></tr>
+<tr id="row_0_56_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__mem__functor4.html" target="_self">const_mem_functor4</a></td><td class="desc">Const_mem_functor4 wraps const methods with 4 argument(s) </td></tr>
+<tr id="row_0_57_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__mem__functor5.html" target="_self">const_mem_functor5</a></td><td class="desc">Const_mem_functor5 wraps const methods with 5 argument(s) </td></tr>
+<tr id="row_0_58_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__mem__functor6.html" target="_self">const_mem_functor6</a></td><td class="desc">Const_mem_functor6 wraps const methods with 6 argument(s) </td></tr>
+<tr id="row_0_59_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__mem__functor7.html" target="_self">const_mem_functor7</a></td><td class="desc">Const_mem_functor7 wraps const methods with 7 argument(s) </td></tr>
+<tr id="row_0_60_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1const__reference__wrapper.html" target="_self">const_reference_wrapper</a></td><td class="desc">Const reference wrapper </td></tr>
+<tr id="row_0_61_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__limit__reference.html" target="_self">const_volatile_limit_reference</a></td><td class="desc">A const_volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>, then <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each<>()</a> will "limit" itself to the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference instead of the derived reference </td></tr>
+<tr id="row_0_62_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html" target="_self">const_volatile_limit_reference< T_type, true ></a></td><td class="desc">Const_volatile_limit_reference object for a class that derives from trackable </td></tr>
+<tr id="row_0_63_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html" target="_self">const_volatile_mem_functor0</a></td><td class="desc">Const_volatile_mem_functor0 wraps const volatile methods with 0 argument(s) </td></tr>
+<tr id="row_0_64_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html" target="_self">const_volatile_mem_functor1</a></td><td class="desc">Const_volatile_mem_functor1 wraps const volatile methods with 1 argument(s) </td></tr>
+<tr id="row_0_65_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html" target="_self">const_volatile_mem_functor2</a></td><td class="desc">Const_volatile_mem_functor2 wraps const volatile methods with 2 argument(s) </td></tr>
+<tr id="row_0_66_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html" target="_self">const_volatile_mem_functor3</a></td><td class="desc">Const_volatile_mem_functor3 wraps const volatile methods with 3 argument(s) </td></tr>
+<tr id="row_0_67_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html" target="_self">const_volatile_mem_functor4</a></td><td class="desc">Const_volatile_mem_functor4 wraps const volatile methods with 4 argument(s) </td></tr>
+<tr id="row_0_68_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html" target="_self">const_volatile_mem_functor5</a></td><td class="desc">Const_volatile_mem_functor5 wraps const volatile methods with 5 argument(s) </td></tr>
+<tr id="row_0_69_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html" target="_self">const_volatile_mem_functor6</a></td><td class="desc">Const_volatile_mem_functor6 wraps const volatile methods with 6 argument(s) </td></tr>
+<tr id="row_0_70_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html" target="_self">const_volatile_mem_functor7</a></td><td class="desc">Const_volatile_mem_functor7 wraps const volatile methods with 7 argument(s) </td></tr>
+<tr id="row_0_71_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1deduce__result__type.html" target="_self">deduce_result_type</a></td><td class="desc">Deduce the return type of a functor </td></tr>
+<tr id="row_0_72_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1exception__catch__functor.html" target="_self">exception_catch_functor</a></td><td class="desc"></td></tr>
+<tr id="row_0_73_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html" target="_self">exception_catch_functor< T_functor, T_catcher, void ></a></td><td class="desc"></td></tr>
+<tr id="row_0_74_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1functor__base.html" target="_self">functor_base</a></td><td class="desc">A hint to the compiler </td></tr>
+<tr id="row_0_75_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1functor__trait.html" target="_self">functor_trait</a></td><td class="desc">Trait that specifies the return type of any type </td></tr>
+<tr id="row_0_76_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1hide__functor.html" target="_self">hide_functor</a></td><td class="desc">Adaptor that adds a dummy parameter to the wrapped functor </td></tr>
+<tr id="row_0_77_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html" target="_self">hide_functor< 0, T_functor ></a></td><td class="desc">Adaptor that adds a dummy parameter to the wrapped functor </td></tr>
+<tr id="row_0_78_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html" target="_self">hide_functor<-1, T_functor ></a></td><td class="desc">Adaptor that adds a dummy parameter to the wrapped functor </td></tr>
+<tr id="row_0_79_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1limit__reference.html" target="_self">limit_reference</a></td><td class="desc">A limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>, then <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each<>()</a> will "limit" itself to the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference instead of the derived reference </td></tr>
+<tr id="row_0_80_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html" target="_self">limit_reference< T_type, true ></a></td><td class="desc">Limit_reference object for a class that derives from trackable </td></tr>
+<tr id="row_0_81_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1mem__functor0.html" target="_self">mem_functor0</a></td><td class="desc">Mem_functor0 wraps methods with 0 argument(s) </td></tr>
+<tr id="row_0_82_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1mem__functor1.html" target="_self">mem_functor1</a></td><td class="desc">Mem_functor1 wraps methods with 1 argument(s) </td></tr>
+<tr id="row_0_83_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1mem__functor2.html" target="_self">mem_functor2</a></td><td class="desc">Mem_functor2 wraps methods with 2 argument(s) </td></tr>
+<tr id="row_0_84_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1mem__functor3.html" target="_self">mem_functor3</a></td><td class="desc">Mem_functor3 wraps methods with 3 argument(s) </td></tr>
+<tr id="row_0_85_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1mem__functor4.html" target="_self">mem_functor4</a></td><td class="desc">Mem_functor4 wraps methods with 4 argument(s) </td></tr>
+<tr id="row_0_86_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1mem__functor5.html" target="_self">mem_functor5</a></td><td class="desc">Mem_functor5 wraps methods with 5 argument(s) </td></tr>
+<tr id="row_0_87_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1mem__functor6.html" target="_self">mem_functor6</a></td><td class="desc">Mem_functor6 wraps methods with 6 argument(s) </td></tr>
+<tr id="row_0_88_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1mem__functor7.html" target="_self">mem_functor7</a></td><td class="desc">Mem_functor7 wraps methods with 7 argument(s) </td></tr>
+<tr id="row_0_89_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1nil.html" target="_self">nil</a></td><td class="desc">Nil struct type </td></tr>
+<tr id="row_0_90_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1pointer__functor0.html" target="_self">pointer_functor0</a></td><td class="desc">Pointer_functor0 wraps existing non-member functions with 0 argument(s) </td></tr>
+<tr id="row_0_91_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1pointer__functor1.html" target="_self">pointer_functor1</a></td><td class="desc">Pointer_functor1 wraps existing non-member functions with 1 argument(s) </td></tr>
+<tr id="row_0_92_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1pointer__functor2.html" target="_self">pointer_functor2</a></td><td class="desc">Pointer_functor2 wraps existing non-member functions with 2 argument(s) </td></tr>
+<tr id="row_0_93_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1pointer__functor3.html" target="_self">pointer_functor3</a></td><td class="desc">Pointer_functor3 wraps existing non-member functions with 3 argument(s) </td></tr>
+<tr id="row_0_94_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1pointer__functor4.html" target="_self">pointer_functor4</a></td><td class="desc">Pointer_functor4 wraps existing non-member functions with 4 argument(s) </td></tr>
+<tr id="row_0_95_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1pointer__functor5.html" target="_self">pointer_functor5</a></td><td class="desc">Pointer_functor5 wraps existing non-member functions with 5 argument(s) </td></tr>
+<tr id="row_0_96_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1pointer__functor6.html" target="_self">pointer_functor6</a></td><td class="desc">Pointer_functor6 wraps existing non-member functions with 6 argument(s) </td></tr>
+<tr id="row_0_97_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1pointer__functor7.html" target="_self">pointer_functor7</a></td><td class="desc">Pointer_functor7 wraps existing non-member functions with 7 argument(s) </td></tr>
+<tr id="row_0_98_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1reference__wrapper.html" target="_self">reference_wrapper</a></td><td class="desc">Reference wrapper </td></tr>
+<tr id="row_0_99_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1retype__functor.html" target="_self">retype_functor</a></td><td class="desc">Adaptor that performs C-style casts on the parameters passed on to the functor </td></tr>
+<tr id="row_0_100_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1retype__return__functor.html" target="_self">retype_return_functor</a></td><td class="desc">Adaptor that performs a C-style cast on the return value of a functor </td></tr>
+<tr id="row_0_101_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html" target="_self">retype_return_functor< void, T_functor ></a></td><td class="desc">Adaptor that performs a C-style cast on the return value of a functor </td></tr>
+<tr id="row_0_102_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_102_" class="arrow" onclick="toggleFolder('0_102_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal.html" target="_self">signal</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates </td></tr>
+<tr id="row_0_102_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_1_1accumulated.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates </td></tr>
+<tr id="row_0_103_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal0.html" target="_self">signal0</a></td><td class="desc">Signal declaration </td></tr>
+<tr id="row_0_104_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal1.html" target="_self">signal1</a></td><td class="desc">Signal declaration </td></tr>
+<tr id="row_0_105_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal2.html" target="_self">signal2</a></td><td class="desc">Signal declaration </td></tr>
+<tr id="row_0_106_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal3.html" target="_self">signal3</a></td><td class="desc">Signal declaration </td></tr>
+<tr id="row_0_107_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal4.html" target="_self">signal4</a></td><td class="desc">Signal declaration </td></tr>
+<tr id="row_0_108_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal5.html" target="_self">signal5</a></td><td class="desc">Signal declaration </td></tr>
+<tr id="row_0_109_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal6.html" target="_self">signal6</a></td><td class="desc">Signal declaration </td></tr>
+<tr id="row_0_110_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal7.html" target="_self">signal7</a></td><td class="desc">Signal declaration </td></tr>
+<tr id="row_0_111_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_111_" class="arrow" onclick="toggleFolder('0_111_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4.html" target="_self">signal< T_return()></a></td><td class="desc">This specialization allow use of the sigc::signal<R(Args...)> syntax, </td></tr>
+<tr id="row_0_111_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal0.html" title="Signal declaration.">sigc::signal0</a> template </td></tr>
+<tr id="row_0_112_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_112_" class="arrow" onclick="toggleFolder('0_112_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html" target="_self">signal< T_return(T_arg1)></a></td><td class="desc">This specialization allow use of the sigc::signal<R(Args...)> syntax, </td></tr>
+<tr id="row_0_112_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal1.html" title="Signal declaration.">sigc::signal1</a> template </td></tr>
+<tr id="row_0_113_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_113_" class="arrow" onclick="toggleFolder('0_113_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html" target="_self">signal< T_return(T_arg1, T_arg2)></a></td><td class="desc">This specialization allow use of the sigc::signal<R(Args...)> syntax, </td></tr>
+<tr id="row_0_113_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal2.html" title="Signal declaration.">sigc::signal2</a> template </td></tr>
+<tr id="row_0_114_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_114_" class="arrow" onclick="toggleFolder('0_114_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html" target="_self">signal< T_return(T_arg1, T_arg2, T_arg3)></a></td><td class="desc">This specialization allow use of the sigc::signal<R(Args...)> syntax, </td></tr>
+<tr id="row_0_114_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal3.html" title="Signal declaration.">sigc::signal3</a> template </td></tr>
+<tr id="row_0_115_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_115_" class="arrow" onclick="toggleFolder('0_115_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html" target="_self">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)></a></td><td class="desc">This specialization allow use of the sigc::signal<R(Args...)> syntax, </td></tr>
+<tr id="row_0_115_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal4.html" title="Signal declaration.">sigc::signal4</a> template </td></tr>
+<tr id="row_0_116_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_116_" class="arrow" onclick="toggleFolder('0_116_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html" target="_self">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)></a></td><td class="desc">This specialization allow use of the sigc::signal<R(Args...)> syntax, </td></tr>
+<tr id="row_0_116_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal5.html" title="Signal declaration.">sigc::signal5</a> template </td></tr>
+<tr id="row_0_117_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_117_" class="arrow" onclick="toggleFolder('0_117_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html" target="_self">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)></a></td><td class="desc">This specialization allow use of the sigc::signal<R(Args...)> syntax, </td></tr>
+<tr id="row_0_117_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal6.html" title="Signal declaration.">sigc::signal6</a> template </td></tr>
+<tr id="row_0_118_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_118_" class="arrow" onclick="toggleFolder('0_118_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html" target="_self">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)></a></td><td class="desc">This specialization allow use of the sigc::signal<R(Args...)> syntax, </td></tr>
+<tr id="row_0_118_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates </td></tr>
+<tr id="row_0_119_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_119_" class="arrow" onclick="toggleFolder('0_119_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">signal< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal0.html" title="Signal declaration.">sigc::signal0</a> template </td></tr>
+<tr id="row_0_119_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal0.html" title="Signal declaration.">sigc::signal0</a> template </td></tr>
+<tr id="row_0_120_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_120_" class="arrow" onclick="toggleFolder('0_120_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal1.html" title="Signal declaration.">sigc::signal1</a> template </td></tr>
+<tr id="row_0_120_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal1.html" title="Signal declaration.">sigc::signal1</a> template </td></tr>
+<tr id="row_0_121_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_121_" class="arrow" onclick="toggleFolder('0_121_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal2.html" title="Signal declaration.">sigc::signal2</a> template </td></tr>
+<tr id="row_0_121_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal2.html" title="Signal declaration.">sigc::signal2</a> template </td></tr>
+<tr id="row_0_122_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_122_" class="arrow" onclick="toggleFolder('0_122_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal3.html" title="Signal declaration.">sigc::signal3</a> template </td></tr>
+<tr id="row_0_122_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal3.html" title="Signal declaration.">sigc::signal3</a> template </td></tr>
+<tr id="row_0_123_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_123_" class="arrow" onclick="toggleFolder('0_123_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal4.html" title="Signal declaration.">sigc::signal4</a> template </td></tr>
+<tr id="row_0_123_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal4.html" title="Signal declaration.">sigc::signal4</a> template </td></tr>
+<tr id="row_0_124_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_124_" class="arrow" onclick="toggleFolder('0_124_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html" target="_self">signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal5.html" title="Signal declaration.">sigc::signal5</a> template </td></tr>
+<tr id="row_0_124_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal5.html" title="Signal declaration.">sigc::signal5</a> template </td></tr>
+<tr id="row_0_125_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_125_" class="arrow" onclick="toggleFolder('0_125_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html" target="_self">signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal6.html" title="Signal declaration.">sigc::signal6</a> template </td></tr>
+<tr id="row_0_125_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal6.html" title="Signal declaration.">sigc::signal6</a> template </td></tr>
+<tr id="row_0_126_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1signal__base.html" target="_self">signal_base</a></td><td class="desc">Base class for the <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates </td></tr>
+<tr id="row_0_127_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot.html" target="_self">slot</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a># templates </td></tr>
+<tr id="row_0_128_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot0.html" target="_self">slot0</a></td><td class="desc">Converts an arbitrary functor to a unified type which is opaque </td></tr>
+<tr id="row_0_129_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot1.html" target="_self">slot1</a></td><td class="desc">Converts an arbitrary functor to a unified type which is opaque </td></tr>
+<tr id="row_0_130_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot2.html" target="_self">slot2</a></td><td class="desc">Converts an arbitrary functor to a unified type which is opaque </td></tr>
+<tr id="row_0_131_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot3.html" target="_self">slot3</a></td><td class="desc">Converts an arbitrary functor to a unified type which is opaque </td></tr>
+<tr id="row_0_132_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot4.html" target="_self">slot4</a></td><td class="desc">Converts an arbitrary functor to a unified type which is opaque </td></tr>
+<tr id="row_0_133_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot5.html" target="_self">slot5</a></td><td class="desc">Converts an arbitrary functor to a unified type which is opaque </td></tr>
+<tr id="row_0_134_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot6.html" target="_self">slot6</a></td><td class="desc">Converts an arbitrary functor to a unified type which is opaque </td></tr>
+<tr id="row_0_135_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot7.html" target="_self">slot7</a></td><td class="desc">Converts an arbitrary functor to a unified type which is opaque </td></tr>
+<tr id="row_0_136_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html" target="_self">slot< T_return(T_arg...)></a></td><td class="desc">Converts an arbitrary functor to a unified type which is opaque </td></tr>
+<tr id="row_0_137_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">slot< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot0.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot0</a> template </td></tr>
+<tr id="row_0_138_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot1.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot1</a> template </td></tr>
+<tr id="row_0_139_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot2.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot2</a> template </td></tr>
+<tr id="row_0_140_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot3.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot3</a> template </td></tr>
+<tr id="row_0_141_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot4.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot4</a> template </td></tr>
+<tr id="row_0_142_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html" target="_self">slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot5.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot5</a> template </td></tr>
+<tr id="row_0_143_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html" target="_self">slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot6.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot6</a> template </td></tr>
+<tr id="row_0_144_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot__base.html" target="_self">slot_base</a></td><td class="desc">Base type for slots </td></tr>
+<tr id="row_0_145_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1slot__const__iterator.html" target="_self">slot_const_iterator</a></td><td class="desc">STL-style const iterator for <a class="el" href="structsigc_1_1slot__list.html" title="STL-style list interface for sigc::signal#.">slot_list</a> </td></tr>
+<tr id="row_0_146_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1slot__iterator.html" target="_self">slot_iterator</a></td><td class="desc">STL-style iterator for <a class="el" href="structsigc_1_1slot__list.html" title="STL-style list interface for sigc::signal#.">slot_list</a> </td></tr>
+<tr id="row_0_147_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1slot__list.html" target="_self">slot_list</a></td><td class="desc">STL-style list interface for <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># </td></tr>
+<tr id="row_0_148_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1track__obj__functor1.html" target="_self">track_obj_functor1</a></td><td class="desc">Track_obj_functor1 wraps a functor and stores a reference to a trackable object </td></tr>
+<tr id="row_0_149_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1track__obj__functor2.html" target="_self">track_obj_functor2</a></td><td class="desc">Track_obj_functor2 wraps a functor and stores 2 references to trackable objects </td></tr>
+<tr id="row_0_150_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1track__obj__functor3.html" target="_self">track_obj_functor3</a></td><td class="desc">Track_obj_functor3 wraps a functor and stores 3 references to trackable objects </td></tr>
+<tr id="row_0_151_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1track__obj__functor4.html" target="_self">track_obj_functor4</a></td><td class="desc">Track_obj_functor4 wraps a functor and stores 4 references to trackable objects </td></tr>
+<tr id="row_0_152_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1track__obj__functor5.html" target="_self">track_obj_functor5</a></td><td class="desc">Track_obj_functor5 wraps a functor and stores 5 references to trackable objects </td></tr>
+<tr id="row_0_153_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1track__obj__functor6.html" target="_self">track_obj_functor6</a></td><td class="desc">Track_obj_functor6 wraps a functor and stores 6 references to trackable objects </td></tr>
+<tr id="row_0_154_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1track__obj__functor7.html" target="_self">track_obj_functor7</a></td><td class="desc">Track_obj_functor7 wraps a functor and stores 7 references to trackable objects </td></tr>
+<tr id="row_0_155_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1trackable.html" target="_self">trackable</a></td><td class="desc">Base class for objects with auto-disconnection </td></tr>
+<tr id="row_0_156_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1type__trait.html" target="_self">type_trait</a></td><td class="desc"></td></tr>
+<tr id="row_0_157_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html" target="_self">type_trait< const T_type & ></a></td><td class="desc"></td></tr>
+<tr id="row_0_158_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1type__trait_3_01T__type_01_6_01_4.html" target="_self">type_trait< T_type & ></a></td><td class="desc"></td></tr>
+<tr id="row_0_159_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html" target="_self">type_trait< T_type[N]></a></td><td class="desc"></td></tr>
+<tr id="row_0_160_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1type__trait_3_01void_01_4.html" target="_self">type_trait< void ></a></td><td class="desc"></td></tr>
+<tr id="row_0_161_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1unwrap__reference.html" target="_self">unwrap_reference</a></td><td class="desc"></td></tr>
+<tr id="row_0_162_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1unwrap__reference_3_01const__reference__wrapper_3_01T__type_01_4_01_4.html" target="_self">unwrap_reference< const_reference_wrapper< T_type > ></a></td><td class="desc"></td></tr>
+<tr id="row_0_163_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1unwrap__reference_3_01reference__wrapper_3_01T__type_01_4_01_4.html" target="_self">unwrap_reference< reference_wrapper< T_type > ></a></td><td class="desc"></td></tr>
+<tr id="row_0_164_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1unwrap__reference_3_01std_1_1reference__wrapper_3_01T__type_01_4_01_4.html" target="_self">unwrap_reference< std::reference_wrapper< T_type > ></a></td><td class="desc"></td></tr>
+<tr id="row_0_165_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1visitor.html" target="_self">visitor</a></td><td class="desc">Sigc::visitor<T_functor>::do_visit_each() performs a functor on each of the targets of a functor </td></tr>
+<tr id="row_0_166_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__limit__reference.html" target="_self">volatile_limit_reference</a></td><td class="desc">A volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>, then <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each<>()</a> will "limit" itself to the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference instead of the derived reference </td></tr>
+<tr id="row_0_167_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html" target="_self">volatile_limit_reference< T_type, true ></a></td><td class="desc">Volatile_limit_reference object for a class that derives from trackable </td></tr>
+<tr id="row_0_168_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__mem__functor0.html" target="_self">volatile_mem_functor0</a></td><td class="desc">Volatile_mem_functor0 wraps volatile methods with 0 argument(s) </td></tr>
+<tr id="row_0_169_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__mem__functor1.html" target="_self">volatile_mem_functor1</a></td><td class="desc">Volatile_mem_functor1 wraps volatile methods with 1 argument(s) </td></tr>
+<tr id="row_0_170_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__mem__functor2.html" target="_self">volatile_mem_functor2</a></td><td class="desc">Volatile_mem_functor2 wraps volatile methods with 2 argument(s) </td></tr>
+<tr id="row_0_171_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__mem__functor3.html" target="_self">volatile_mem_functor3</a></td><td class="desc">Volatile_mem_functor3 wraps volatile methods with 3 argument(s) </td></tr>
+<tr id="row_0_172_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__mem__functor4.html" target="_self">volatile_mem_functor4</a></td><td class="desc">Volatile_mem_functor4 wraps volatile methods with 4 argument(s) </td></tr>
+<tr id="row_0_173_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__mem__functor5.html" target="_self">volatile_mem_functor5</a></td><td class="desc">Volatile_mem_functor5 wraps volatile methods with 5 argument(s) </td></tr>
+<tr id="row_0_174_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__mem__functor6.html" target="_self">volatile_mem_functor6</a></td><td class="desc">Volatile_mem_functor6 wraps volatile methods with 6 argument(s) </td></tr>
+<tr id="row_0_175_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__mem__functor7.html" target="_self">volatile_mem_functor7</a></td><td class="desc">Volatile_mem_functor7 wraps volatile methods with 7 argument(s) </td></tr>
+</table>
+</div><!-- directory -->
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Index</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">Class Index</div> </div>
+</div><!--header-->
+<div class="contents">
+<div class="qindex"><a class="qindex" href="#letter_A">A</a> | <a class="qindex" href="#letter_B">B</a> | <a class="qindex" href="#letter_C">C</a> | <a class="qindex" href="#letter_D">D</a> | <a class="qindex" href="#letter_E">E</a> | <a class="qindex" href="#letter_F">F</a> | <a class="qindex" href="#letter_H">H</a> | <a class="qindex" href="#letter_L">L</a> | <a class="qindex" href="#letter_M">M</a> | <a class="qindex" href="#letter_N">N</a> | <a class="qindex" href="#letter_P">P</a> | <a class="qindex" href="#letter_R">R</a> | <a class="qindex" href="#letter_S">S</a> | <a class="qindex" href="#letter_T">T</a> | <a class="qindex" href="#letter_U">U</a> | <a class="qindex" href="#letter_V">V</a></div>
+<div class="classindex">
+<dl class="classindex even">
+<dt class="alphachar"><a name="letter_A">A</a></dt>
+<dd><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::accumulated</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html">signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::accumulated</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html">signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::accumulated</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html">signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::accumulated</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html">signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::accumulated</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html">signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::accumulated</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html">signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::accumulated</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html">signal< T_return, nil, nil, nil, nil, nil, nil, nil >::accumulated</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::accumulated</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::accumulated</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::accumulated</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html">signal< T_return(T_arg1, T_arg2, T_arg3)>::accumulated</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html">signal< T_return(T_arg1, T_arg2)>::accumulated</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html">signal< T_return(T_arg1)>::accumulated</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html">signal< T_return()>::accumulated</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_1_1accumulated.html">signal::accumulated</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1adaptor__base.html">adaptor_base</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1adaptor__functor.html">adaptor_functor</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html">adaptor_trait< T_functor, false ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html">adaptor_trait< T_functor, true ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1adapts.html">adapts</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd></dl>
+<dl class="classindex odd">
+<dt class="alphachar"><a name="letter_B">B</a></dt>
+<dd><a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1bind__return__functor.html">bind_return_functor</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__argument.html">bound_argument</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html">bound_argument< const_reference_wrapper< T_wrapped > ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html">bound_argument< reference_wrapper< T_wrapped > ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html">bound_argument< std::reference_wrapper< T_wrapped > ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__const__mem__functor0.html">bound_const_mem_functor0</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__const__mem__functor1.html">bound_const_mem_functor1</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__const__mem__functor2.html">bound_const_mem_functor2</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__const__mem__functor3.html">bound_const_mem_functor3</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__const__mem__functor4.html">bound_const_mem_functor4</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__const__mem__functor5.html">bound_const_mem_functor5</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__const__mem__functor6.html">bound_const_mem_functor6</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__const__mem__functor7.html">bound_const_mem_functor7</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">bound_const_volatile_mem_functor0</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">bound_const_volatile_mem_functor1</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">bound_const_volatile_mem_functor2</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">bound_const_volatile_mem_functor3</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">bound_const_volatile_mem_functor4</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">bound_const_volatile_mem_functor5</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">bound_const_volatile_mem_functor6</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">bound_const_volatile_mem_functor7</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__mem__functor0.html">bound_mem_functor0</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__mem__functor1.html">bound_mem_functor1</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__mem__functor2.html">bound_mem_functor2</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__mem__functor3.html">bound_mem_functor3</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__mem__functor4.html">bound_mem_functor4</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__mem__functor5.html">bound_mem_functor5</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__mem__functor6.html">bound_mem_functor6</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__mem__functor7.html">bound_mem_functor7</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">bound_volatile_mem_functor0</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">bound_volatile_mem_functor1</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">bound_volatile_mem_functor2</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">bound_volatile_mem_functor3</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">bound_volatile_mem_functor4</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">bound_volatile_mem_functor5</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">bound_volatile_mem_functor6</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">bound_volatile_mem_functor7</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd></dl>
+<dl class="classindex even">
+<dt class="alphachar"><a name="letter_C">C</a></dt>
+<dd><a class="el" href="classsigc_1_1can__deduce__result__type__with__decltype.html">can_deduce_result_type_with_decltype</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1compose1__functor.html">compose1_functor</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1compose2__functor.html">compose2_functor</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1connection.html">connection</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1const__limit__reference.html">const_limit_reference</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html">const_limit_reference< T_type, true ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1const__mem__functor0.html">const_mem_functor0</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1const__mem__functor1.html">const_mem_functor1</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1const__mem__functor2.html">const_mem_functor2</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1const__mem__functor3.html">const_mem_functor3</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1const__mem__functor4.html">const_mem_functor4</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1const__mem__functor5.html">const_mem_functor5</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1const__mem__functor6.html">const_mem_functor6</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1const__mem__functor7.html">const_mem_functor7</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1const__reference__wrapper.html">const_reference_wrapper</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1const__volatile__limit__reference.html">const_volatile_limit_reference</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html">const_volatile_limit_reference< T_type, true ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">const_volatile_mem_functor0</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">const_volatile_mem_functor1</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">const_volatile_mem_functor2</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">const_volatile_mem_functor3</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">const_volatile_mem_functor4</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">const_volatile_mem_functor5</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">const_volatile_mem_functor6</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">const_volatile_mem_functor7</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd></dl>
+<dl class="classindex odd">
+<dt class="alphachar"><a name="letter_D">D</a></dt>
+<dd><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd></dl>
+<dl class="classindex even">
+<dt class="alphachar"><a name="letter_E">E</a></dt>
+<dd><a class="el" href="structsigc_1_1exception__catch__functor.html">exception_catch_functor</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html">exception_catch_functor< T_functor, T_catcher, void ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd></dl>
+<dl class="classindex odd">
+<dt class="alphachar"><a name="letter_F">F</a></dt>
+<dd><a class="el" href="structsigc_1_1functor__base.html">functor_base</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1functor__trait.html">functor_trait</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd></dl>
+<dl class="classindex even">
+<dt class="alphachar"><a name="letter_H">H</a></dt>
+<dd><a class="el" href="structsigc_1_1hide__functor.html">hide_functor</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html">hide_functor< 0, T_functor ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html">hide_functor<-1, T_functor ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd></dl>
+<dl class="classindex odd">
+<dt class="alphachar"><a name="letter_L">L</a></dt>
+<dd><a class="el" href="classsigc_1_1limit__reference.html">limit_reference</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html">limit_reference< T_type, true ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd></dl>
+<dl class="classindex even">
+<dt class="alphachar"><a name="letter_M">M</a></dt>
+<dd><a class="el" href="classsigc_1_1mem__functor0.html">mem_functor0</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1mem__functor1.html">mem_functor1</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1mem__functor2.html">mem_functor2</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1mem__functor3.html">mem_functor3</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1mem__functor4.html">mem_functor4</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1mem__functor5.html">mem_functor5</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1mem__functor6.html">mem_functor6</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1mem__functor7.html">mem_functor7</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd></dl>
+<dl class="classindex odd">
+<dt class="alphachar"><a name="letter_N">N</a></dt>
+<dd><a class="el" href="structsigc_1_1nil.html">nil</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd></dl>
+<dl class="classindex even">
+<dt class="alphachar"><a name="letter_P">P</a></dt>
+<dd><a class="el" href="classsigc_1_1pointer__functor0.html">pointer_functor0</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1pointer__functor1.html">pointer_functor1</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1pointer__functor2.html">pointer_functor2</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1pointer__functor3.html">pointer_functor3</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1pointer__functor4.html">pointer_functor4</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1pointer__functor5.html">pointer_functor5</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1pointer__functor6.html">pointer_functor6</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1pointer__functor7.html">pointer_functor7</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd></dl>
+<dl class="classindex odd">
+<dt class="alphachar"><a name="letter_R">R</a></dt>
+<dd><a class="el" href="structsigc_1_1reference__wrapper.html">reference_wrapper</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1retype__return__functor.html">retype_return_functor</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html">retype_return_functor< void, T_functor ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd></dl>
+<dl class="classindex even">
+<dt class="alphachar"><a name="letter_S">S</a></dt>
+<dd><a class="el" href="classsigc_1_1signal.html">signal</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal0.html">signal0</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal1.html">signal1</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal2.html">signal2</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal3.html">signal3</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal4.html">signal4</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal5.html">signal5</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal6.html">signal6</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal7.html">signal7</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4.html">signal< T_return()></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html">signal< T_return(T_arg1)></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html">signal< T_return(T_arg1, T_arg2)></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3)></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, nil, nil, nil, nil, nil, nil, nil ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1slot.html">slot</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1slot0.html">slot0</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1slot1.html">slot1</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1slot2.html">slot2</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1slot3.html">slot3</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1slot4.html">slot4</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1slot5.html">slot5</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1slot6.html">slot6</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1slot7.html">slot7</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html">slot< T_return(T_arg...)></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">slot< T_return, nil, nil, nil, nil, nil, nil, nil ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html">slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html">slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html">slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1slot__const__iterator.html">slot_const_iterator</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1slot__iterator.html">slot_iterator</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1slot__list.html">slot_list</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd></dl>
+<dl class="classindex odd">
+<dt class="alphachar"><a name="letter_T">T</a></dt>
+<dd><a class="el" href="classsigc_1_1track__obj__functor1.html">track_obj_functor1</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1track__obj__functor2.html">track_obj_functor2</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1track__obj__functor3.html">track_obj_functor3</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1track__obj__functor4.html">track_obj_functor4</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1track__obj__functor5.html">track_obj_functor5</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1track__obj__functor6.html">track_obj_functor6</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1track__obj__functor7.html">track_obj_functor7</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1trackable.html">trackable</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1type__trait.html">type_trait</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html">type_trait< const T_type & ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1type__trait_3_01T__type_01_6_01_4.html">type_trait< T_type & ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html">type_trait< T_type[N]></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1type__trait_3_01void_01_4.html">type_trait< void ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd></dl>
+<dl class="classindex even">
+<dt class="alphachar"><a name="letter_U">U</a></dt>
+<dd><a class="el" href="structsigc_1_1unwrap__reference.html">unwrap_reference</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1unwrap__reference_3_01const__reference__wrapper_3_01T__type_01_4_01_4.html">unwrap_reference< const_reference_wrapper< T_type > ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1unwrap__reference_3_01reference__wrapper_3_01T__type_01_4_01_4.html">unwrap_reference< reference_wrapper< T_type > ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="structsigc_1_1unwrap__reference_3_01std_1_1reference__wrapper_3_01T__type_01_4_01_4.html">unwrap_reference< std::reference_wrapper< T_type > ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd></dl>
+<dl class="classindex odd">
+<dt class="alphachar"><a name="letter_V">V</a></dt>
+<dd><a class="el" href="structsigc_1_1visitor.html">visitor</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1volatile__limit__reference.html">volatile_limit_reference</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html">volatile_limit_reference< T_type, true ></a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1volatile__mem__functor0.html">volatile_mem_functor0</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1volatile__mem__functor1.html">volatile_mem_functor1</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1volatile__mem__functor2.html">volatile_mem_functor2</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1volatile__mem__functor3.html">volatile_mem_functor3</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1volatile__mem__functor4.html">volatile_mem_functor4</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1volatile__mem__functor5.html">volatile_mem_functor5</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1volatile__mem__functor6.html">volatile_mem_functor6</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd><dd><a class="el" href="classsigc_1_1volatile__mem__functor7.html">volatile_mem_functor7</a> (<a class="el" href="namespacesigc.html">sigc</a>)</dd></dl>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__argument.html">bound_argument</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_argument< T_type > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__argument.html">sigc::bound_argument< T_type ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__argument.html#a495bb69a41b38eda5d6ace5a36807a37">bound_argument</a>(const T_type & _A_argument)</td><td class="entry"><a class="el" href="classsigc_1_1bound__argument.html">sigc::bound_argument< T_type ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__argument.html#af1cf20526bade89328a1ed398055bbba">invoke</a>()</td><td class="entry"><a class="el" href="classsigc_1_1bound__argument.html">sigc::bound_argument< T_type ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__argument.html#ab29e53c5e983c45e4963e0ecace26465">visit</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1bound__argument.html">sigc::bound_argument< T_type ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_argument< T_type > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__argument.html">bound_argument</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1bound__argument-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_argument< T_type > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>A bound_argument<Foo> object stores a bound (for instance, with <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">sigc::bind()</a>, or <a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a" title="Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed funct...">sigc::bind_return()</a>) argument.
+ <a href="classsigc_1_1bound__argument.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/bound_argument.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a495bb69a41b38eda5d6ace5a36807a37"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__argument.html#a495bb69a41b38eda5d6ace5a36807a37">bound_argument</a> (const T_type & _A_argument)</td></tr>
+<tr class="memdesc:a495bb69a41b38eda5d6ace5a36807a37"><td class="mdescLeft"> </td><td class="mdescRight">Constructor. <a href="classsigc_1_1bound__argument.html#a495bb69a41b38eda5d6ace5a36807a37">More...</a><br /></td></tr>
+<tr class="separator:a495bb69a41b38eda5d6ace5a36807a37"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af1cf20526bade89328a1ed398055bbba"><td class="memItemLeft" align="right" valign="top">T_type & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__argument.html#af1cf20526bade89328a1ed398055bbba">invoke</a> ()</td></tr>
+<tr class="memdesc:af1cf20526bade89328a1ed398055bbba"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the entity to pass to the bound functor or return. <a href="classsigc_1_1bound__argument.html#af1cf20526bade89328a1ed398055bbba">More...</a><br /></td></tr>
+<tr class="separator:af1cf20526bade89328a1ed398055bbba"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab29e53c5e983c45e4963e0ecace26465"><td class="memItemLeft" align="right" valign="top">const T_type & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__argument.html#ab29e53c5e983c45e4963e0ecace26465">visit</a> () const</td></tr>
+<tr class="memdesc:ab29e53c5e983c45e4963e0ecace26465"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the entity to visit in <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each()</a>. <a href="classsigc_1_1bound__argument.html#ab29e53c5e983c45e4963e0ecace26465">More...</a><br /></td></tr>
+<tr class="separator:ab29e53c5e983c45e4963e0ecace26465"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_type><br />
+class sigc::bound_argument< T_type ></h3>
+
+<p>A bound_argument<Foo> object stores a bound (for instance, with <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">sigc::bind()</a>, or <a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a" title="Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed funct...">sigc::bind_return()</a>) argument. </p>
+<p>If Foo is a wrapped reference to a class Bar (reference_wrapper<Bar>) then this object is implemented on top of a <a class="el" href="classsigc_1_1limit__reference.html" title="A limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from sig...">limit_reference</a>. When the slot is invoked, the <a class="el" href="classsigc_1_1limit__reference.html#affd2902cd78ccdae45c499058c83e992" title="Retrieve the reference.">limit_reference::invoke()</a> method provides the argument (a Bar&). When the slot is visited (e.g. <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each<>()</a>), we simply visit the <a class="el" href="classsigc_1_1limit__reference.html" title="A limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from sig...">limit_reference</a>, which will visit the derived type, or a <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> base if necessary.</p>
+<p>Likewise, If Foo is a wrapped const reference to a class Bar (const_reference_wrapper<Bar>) then this object is implemented on top of a <a class="el" href="classsigc_1_1const__limit__reference.html" title="A const_limit_reference<Foo> object stores a reference (Foo&), but make sure that,...">const_limit_reference</a>.</p>
+<p>If Foo is something else (such as an argument that is bound by value) <a class="el" href="classsigc_1_1bound__argument.html" title="A bound_argument<Foo> object stores a bound (for instance, with sigc::bind(), or sigc::bind_return())...">bound_argument</a> just stores a cop of that value, and both <a class="el" href="classsigc_1_1bound__argument.html#af1cf20526bade89328a1ed398055bbba" title="Retrieve the entity to pass to the bound functor or return.">invoke()</a> and <a class="el" href="classsigc_1_1bound__argument.html#ab29e53c5e983c45e4963e0ecace26465" title="Retrieve the entity to visit in visit_each().">visit()</a> simply return it.</p>
+<p>This object is used by the bind_functor<> and bind_return_functor<> objects, depending on whether the argument is bound as a parameter or as a return value.</p>
+<p>The general template implementation is used for parameters that are passed by value. <em>T_type</em> The type of the bound argument. </p>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a495bb69a41b38eda5d6ace5a36807a37"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a495bb69a41b38eda5d6ace5a36807a37">◆ </a></span>bound_argument()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__argument.html">sigc::bound_argument</a>< T_type >::<a class="el" href="classsigc_1_1bound__argument.html">bound_argument</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_type & </td>
+ <td class="paramname"><em>_A_argument</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_argument</td><td>The argument to bind. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="af1cf20526bade89328a1ed398055bbba"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af1cf20526bade89328a1ed398055bbba">◆ </a></span>invoke()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_type& <a class="el" href="classsigc_1_1bound__argument.html">sigc::bound_argument</a>< T_type >::invoke </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Retrieve the entity to pass to the bound functor or return. </p>
+<dl class="section return"><dt>Returns</dt><dd>The bound argument. </dd></dl>
+
+</div>
+</div>
+<a id="ab29e53c5e983c45e4963e0ecace26465"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab29e53c5e983c45e4963e0ecace26465">◆ </a></span>visit()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">const T_type& <a class="el" href="classsigc_1_1bound__argument.html">sigc::bound_argument</a>< T_type >::visit </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Retrieve the entity to visit in <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each()</a>. </p>
+<dl class="section return"><dt>Returns</dt><dd>The bound argument. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html">bound_argument< const_reference_wrapper< T_wrapped > ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_argument< const_reference_wrapper< T_wrapped > > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html">sigc::bound_argument< const_reference_wrapper< T_wrapped > ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html#afdfab4386d34bd03e82b05a2eb1f2afe">bound_argument</a>(const const_reference_wrapper< T_wrapped > & _A_argument)</td><td class="entry"><a class="el" href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html">sigc::bound_argument< const_reference_wrapper< T_wrapped > ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html#aa08b2efa73ad0a928f0be217da940671">invoke</a>()</td><td class="entry"><a class="el" href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html">sigc::bound_argument< const_reference_wrapper< T_wrapped > ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html#a11b6cda42100c2c463e50942c41ff9eb">visit</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html">sigc::bound_argument< const_reference_wrapper< T_wrapped > ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_argument< const_reference_wrapper< T_wrapped > > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html">bound_argument< const_reference_wrapper< T_wrapped > ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_argument< const_reference_wrapper< T_wrapped > > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__argument.html" title="A bound_argument<Foo> object stores a bound (for instance, with sigc::bind(), or sigc::bind_return())...">bound_argument</a> object for a bound argument that is passed by <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">bind()</a> or returned by <a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a" title="Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed funct...">bind_return()</a> by const reference, specialized for const reference_wrapper<> types.
+ <a href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/bound_argument.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:afdfab4386d34bd03e82b05a2eb1f2afe"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html#afdfab4386d34bd03e82b05a2eb1f2afe">bound_argument</a> (const <a class="el" href="structsigc_1_1const__reference__wrapper.html">const_reference_wrapper</a>< T_wrapped > & _A_argument)</td></tr>
+<tr class="memdesc:afdfab4386d34bd03e82b05a2eb1f2afe"><td class="mdescLeft"> </td><td class="mdescRight">Constructor. <a href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html#afdfab4386d34bd03e82b05a2eb1f2afe">More...</a><br /></td></tr>
+<tr class="separator:afdfab4386d34bd03e82b05a2eb1f2afe"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa08b2efa73ad0a928f0be217da940671"><td class="memItemLeft" align="right" valign="top">const T_wrapped & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html#aa08b2efa73ad0a928f0be217da940671">invoke</a> ()</td></tr>
+<tr class="memdesc:aa08b2efa73ad0a928f0be217da940671"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the entity to pass to the bound functor or return. <a href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html#aa08b2efa73ad0a928f0be217da940671">More...</a><br /></td></tr>
+<tr class="separator:aa08b2efa73ad0a928f0be217da940671"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a11b6cda42100c2c463e50942c41ff9eb"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1const__limit__reference.html">const_limit_reference</a>< T_wrapped > & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html#a11b6cda42100c2c463e50942c41ff9eb">visit</a> () const</td></tr>
+<tr class="memdesc:a11b6cda42100c2c463e50942c41ff9eb"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the entity to visit in <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each()</a>. <a href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html#a11b6cda42100c2c463e50942c41ff9eb">More...</a><br /></td></tr>
+<tr class="separator:a11b6cda42100c2c463e50942c41ff9eb"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_wrapped><br />
+class sigc::bound_argument< const_reference_wrapper< T_wrapped > ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__argument.html" title="A bound_argument<Foo> object stores a bound (for instance, with sigc::bind(), or sigc::bind_return())...">bound_argument</a> object for a bound argument that is passed by <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">bind()</a> or returned by <a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a" title="Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed funct...">bind_return()</a> by const reference, specialized for const reference_wrapper<> types. </p>
+<ul>
+<li><em>T_wrapped</em> The type of the bound argument. </li>
+</ul>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="afdfab4386d34bd03e82b05a2eb1f2afe"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#afdfab4386d34bd03e82b05a2eb1f2afe">◆ </a></span>bound_argument()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_wrapped > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__argument.html">sigc::bound_argument</a>< <a class="el" href="structsigc_1_1const__reference__wrapper.html">const_reference_wrapper</a>< T_wrapped > >::<a class="el" href="classsigc_1_1bound__argument.html">bound_argument</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="structsigc_1_1const__reference__wrapper.html">const_reference_wrapper</a>< T_wrapped > & </td>
+ <td class="paramname"><em>_A_argument</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_argument</td><td>The argument to bind. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="aa08b2efa73ad0a928f0be217da940671"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa08b2efa73ad0a928f0be217da940671">◆ </a></span>invoke()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_wrapped > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">const T_wrapped& <a class="el" href="classsigc_1_1bound__argument.html">sigc::bound_argument</a>< <a class="el" href="structsigc_1_1const__reference__wrapper.html">const_reference_wrapper</a>< T_wrapped > >::invoke </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Retrieve the entity to pass to the bound functor or return. </p>
+<dl class="section return"><dt>Returns</dt><dd>The bound argument. </dd></dl>
+
+</div>
+</div>
+<a id="a11b6cda42100c2c463e50942c41ff9eb"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a11b6cda42100c2c463e50942c41ff9eb">◆ </a></span>visit()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_wrapped > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">const <a class="el" href="classsigc_1_1const__limit__reference.html">const_limit_reference</a><T_wrapped>& <a class="el" href="classsigc_1_1bound__argument.html">sigc::bound_argument</a>< <a class="el" href="structsigc_1_1const__reference__wrapper.html">const_reference_wrapper</a>< T_wrapped > >::visit </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Retrieve the entity to visit in <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each()</a>. </p>
+<dl class="section return"><dt>Returns</dt><dd>The const_limited_reference to the bound argument. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html">bound_argument< reference_wrapper< T_wrapped > ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_argument< reference_wrapper< T_wrapped > > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html">sigc::bound_argument< reference_wrapper< T_wrapped > ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html#a46f705d774a2436055785b7a55830349">bound_argument</a>(const reference_wrapper< T_wrapped > & _A_argument)</td><td class="entry"><a class="el" href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html">sigc::bound_argument< reference_wrapper< T_wrapped > ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html#adbeb73917559e0764bf367dfc6c4141d">invoke</a>()</td><td class="entry"><a class="el" href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html">sigc::bound_argument< reference_wrapper< T_wrapped > ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html#a5123890110dc1013071e68a615692ce3">visit</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html">sigc::bound_argument< reference_wrapper< T_wrapped > ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_argument< reference_wrapper< T_wrapped > > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html">bound_argument< reference_wrapper< T_wrapped > ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_argument< reference_wrapper< T_wrapped > > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__argument.html" title="A bound_argument<Foo> object stores a bound (for instance, with sigc::bind(), or sigc::bind_return())...">bound_argument</a> object for a bound argument that is passed by <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">bind()</a> or returned by <a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a" title="Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed funct...">bind_return()</a> by reference, specialized for reference_wrapper<> types.
+ <a href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/bound_argument.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a46f705d774a2436055785b7a55830349"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html#a46f705d774a2436055785b7a55830349">bound_argument</a> (const <a class="el" href="structsigc_1_1reference__wrapper.html">reference_wrapper</a>< T_wrapped > & _A_argument)</td></tr>
+<tr class="memdesc:a46f705d774a2436055785b7a55830349"><td class="mdescLeft"> </td><td class="mdescRight">Constructor. <a href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html#a46f705d774a2436055785b7a55830349">More...</a><br /></td></tr>
+<tr class="separator:a46f705d774a2436055785b7a55830349"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adbeb73917559e0764bf367dfc6c4141d"><td class="memItemLeft" align="right" valign="top">T_wrapped & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html#adbeb73917559e0764bf367dfc6c4141d">invoke</a> ()</td></tr>
+<tr class="memdesc:adbeb73917559e0764bf367dfc6c4141d"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the entity to pass to the bound functor or return. <a href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html#adbeb73917559e0764bf367dfc6c4141d">More...</a><br /></td></tr>
+<tr class="separator:adbeb73917559e0764bf367dfc6c4141d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5123890110dc1013071e68a615692ce3"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1limit__reference.html">limit_reference</a>< T_wrapped > & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html#a5123890110dc1013071e68a615692ce3">visit</a> () const</td></tr>
+<tr class="memdesc:a5123890110dc1013071e68a615692ce3"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the entity to visit in <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each()</a>. <a href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html#a5123890110dc1013071e68a615692ce3">More...</a><br /></td></tr>
+<tr class="separator:a5123890110dc1013071e68a615692ce3"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_wrapped><br />
+class sigc::bound_argument< reference_wrapper< T_wrapped > ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__argument.html" title="A bound_argument<Foo> object stores a bound (for instance, with sigc::bind(), or sigc::bind_return())...">bound_argument</a> object for a bound argument that is passed by <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">bind()</a> or returned by <a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a" title="Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed funct...">bind_return()</a> by reference, specialized for reference_wrapper<> types. </p>
+<p><em>T_wrapped</em> The type of the bound argument. </p>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a46f705d774a2436055785b7a55830349"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a46f705d774a2436055785b7a55830349">◆ </a></span>bound_argument()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_wrapped > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__argument.html">sigc::bound_argument</a>< <a class="el" href="structsigc_1_1reference__wrapper.html">reference_wrapper</a>< T_wrapped > >::<a class="el" href="classsigc_1_1bound__argument.html">bound_argument</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="structsigc_1_1reference__wrapper.html">reference_wrapper</a>< T_wrapped > & </td>
+ <td class="paramname"><em>_A_argument</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_argument</td><td>The argument to bind. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="adbeb73917559e0764bf367dfc6c4141d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#adbeb73917559e0764bf367dfc6c4141d">◆ </a></span>invoke()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_wrapped > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_wrapped& <a class="el" href="classsigc_1_1bound__argument.html">sigc::bound_argument</a>< <a class="el" href="structsigc_1_1reference__wrapper.html">reference_wrapper</a>< T_wrapped > >::invoke </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Retrieve the entity to pass to the bound functor or return. </p>
+<dl class="section return"><dt>Returns</dt><dd>The bound argument. </dd></dl>
+
+</div>
+</div>
+<a id="a5123890110dc1013071e68a615692ce3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5123890110dc1013071e68a615692ce3">◆ </a></span>visit()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_wrapped > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">const <a class="el" href="classsigc_1_1limit__reference.html">limit_reference</a><T_wrapped>& <a class="el" href="classsigc_1_1bound__argument.html">sigc::bound_argument</a>< <a class="el" href="structsigc_1_1reference__wrapper.html">reference_wrapper</a>< T_wrapped > >::visit </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Retrieve the entity to visit in <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each()</a>. </p>
+<dl class="section return"><dt>Returns</dt><dd>The limited_reference to the bound argument. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html">bound_argument< std::reference_wrapper< T_wrapped > ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_argument< std::reference_wrapper< T_wrapped > > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html">sigc::bound_argument< std::reference_wrapper< T_wrapped > ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html#a597709183c9a0b753f4674aaab80b4ff">bound_argument</a>(const std::reference_wrapper< T_wrapped > & _A_argument)</td><td class="entry"><a class="el" href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html">sigc::bound_argument< std::reference_wrapper< T_wrapped > ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html#a38950827998907494c25397f01552730">invoke</a>()</td><td class="entry"><a class="el" href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html">sigc::bound_argument< std::reference_wrapper< T_wrapped > ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html#a3d34b13540ac33e677024727ffd3a36e">visit</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html">sigc::bound_argument< std::reference_wrapper< T_wrapped > ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_argument< std::reference_wrapper< T_wrapped > > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html">bound_argument< std::reference_wrapper< T_wrapped > ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_argument< std::reference_wrapper< T_wrapped > > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__argument.html" title="A bound_argument<Foo> object stores a bound (for instance, with sigc::bind(), or sigc::bind_return())...">bound_argument</a> object for a bound argument that is passed by <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">bind()</a> or returned by <a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a" title="Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed funct...">bind_return()</a> by reference, specialized for std::reference_wrapper<> types.
+ <a href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/bound_argument.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a597709183c9a0b753f4674aaab80b4ff"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html#a597709183c9a0b753f4674aaab80b4ff">bound_argument</a> (const <a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a03225.html">std::reference_wrapper</a>< T_wrapped > & _A_argument)</td></tr>
+<tr class="memdesc:a597709183c9a0b753f4674aaab80b4ff"><td class="mdescLeft"> </td><td class="mdescRight">Constructor. <a href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html#a597709183c9a0b753f4674aaab80b4ff">More...</a><br /></td></tr>
+<tr class="separator:a597709183c9a0b753f4674aaab80b4ff"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a38950827998907494c25397f01552730"><td class="memItemLeft" align="right" valign="top">T_wrapped & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html#a38950827998907494c25397f01552730">invoke</a> ()</td></tr>
+<tr class="memdesc:a38950827998907494c25397f01552730"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the entity to pass to the bound functor or return. <a href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html#a38950827998907494c25397f01552730">More...</a><br /></td></tr>
+<tr class="separator:a38950827998907494c25397f01552730"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3d34b13540ac33e677024727ffd3a36e"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1limit__reference.html">limit_reference</a>< T_wrapped > & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html#a3d34b13540ac33e677024727ffd3a36e">visit</a> () const</td></tr>
+<tr class="memdesc:a3d34b13540ac33e677024727ffd3a36e"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the entity to visit in <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each()</a>. <a href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html#a3d34b13540ac33e677024727ffd3a36e">More...</a><br /></td></tr>
+<tr class="separator:a3d34b13540ac33e677024727ffd3a36e"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_wrapped><br />
+class sigc::bound_argument< std::reference_wrapper< T_wrapped > ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__argument.html" title="A bound_argument<Foo> object stores a bound (for instance, with sigc::bind(), or sigc::bind_return())...">bound_argument</a> object for a bound argument that is passed by <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">bind()</a> or returned by <a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a" title="Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed funct...">bind_return()</a> by reference, specialized for std::reference_wrapper<> types. </p>
+<p><em>T_wrapped</em> The type of the bound argument. </p>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a597709183c9a0b753f4674aaab80b4ff"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a597709183c9a0b753f4674aaab80b4ff">◆ </a></span>bound_argument()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_wrapped > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__argument.html">sigc::bound_argument</a>< <a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a03225.html">std::reference_wrapper</a>< T_wrapped > >::<a class="el" href="classsigc_1_1bound__argument.html">bound_argument</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a03225.html">std::reference_wrapper</a>< T_wrapped > & </td>
+ <td class="paramname"><em>_A_argument</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_argument</td><td>The argument to bind. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a38950827998907494c25397f01552730"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a38950827998907494c25397f01552730">◆ </a></span>invoke()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_wrapped > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_wrapped& <a class="el" href="classsigc_1_1bound__argument.html">sigc::bound_argument</a>< <a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a03225.html">std::reference_wrapper</a>< T_wrapped > >::invoke </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Retrieve the entity to pass to the bound functor or return. </p>
+<dl class="section return"><dt>Returns</dt><dd>The bound argument. </dd></dl>
+
+</div>
+</div>
+<a id="a3d34b13540ac33e677024727ffd3a36e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3d34b13540ac33e677024727ffd3a36e">◆ </a></span>visit()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_wrapped > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">const <a class="el" href="classsigc_1_1limit__reference.html">limit_reference</a><T_wrapped>& <a class="el" href="classsigc_1_1bound__argument.html">sigc::bound_argument</a>< <a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a03225.html">std::reference_wrapper</a>< T_wrapped > >::visit </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Retrieve the entity to visit in <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each()</a>. </p>
+<dl class="section return"><dt>Returns</dt><dd>The limited_reference to the bound argument. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html">bound_const_mem_functor0</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_const_mem_functor0< T_return, T_obj > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__const__mem__functor0.html">sigc::bound_const_mem_functor0< T_return, T_obj ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html#a67756fc7a32eb42309a1d55aea2eeb19">bound_const_mem_functor0</a>(const T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html">sigc::bound_const_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html#a44aeae8d1432f66fce9cd385094b78fa">bound_const_mem_functor0</a>(const T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html">sigc::bound_const_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor0.html#a49bba4c8045b8b6933b8f5a854ac98d6">const_mem_functor0</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor0.html">sigc::const_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor0.html#a27895e58972642453f7b853f25a66f42">const_mem_functor0</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor0.html">sigc::const_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor0.html#a215359b20450c2afe93496826ac45c1d">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor0.html">sigc::const_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html#a12ae83ad7820bd716ed8a07484a339d9">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html">sigc::bound_const_mem_functor0< T_return, T_obj ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html#afe36947825350dc17d7fed286f57c32a">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html">sigc::bound_const_mem_functor0< T_return, T_obj ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html#a7949abb2e0a675ab7faccf4b0c2b5480">operator()</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html">sigc::bound_const_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor0.html#abcc08c39943577648dac107692e5b34a">sigc::const_mem_functor0::operator()</a>(const T_obj * _A_obj) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor0.html">sigc::const_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor0.html#ac388853f99f074e549c8784d1a38f46b">sigc::const_mem_functor0::operator()</a>(const T_obj & _A_obj) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor0.html">sigc::const_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor0.html#a553cd4d85524b5deea445b67773527bf">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor0.html">sigc::const_mem_functor0< T_return, T_obj ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_const_mem_functor0< T_return, T_obj > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html">bound_const_mem_functor0</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__const__mem__functor0-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_const_mem_functor0< T_return, T_obj > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__const__mem__functor0.html" title="bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance.">bound_const_mem_functor0</a> encapsulates a const method with 0 arguments and an object instance.
+ <a href="classsigc_1_1bound__const__mem__functor0.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_const_mem_functor0< T_return, T_obj >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__const__mem__functor0__inherit__graph.png" border="0" usemap="#asigc_1_1bound__const__mem__functor0_3_01T__return_00_01T__obj_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__const__mem__functor0_3_01T__return_00_01T__obj_01_4_inherit__map" id="asigc_1_1bound__const__mem__functor0_3_01T__return_00_01T__obj_01_4_inherit__map">
+<area shape="rect" title="bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance." alt="" coords="13,169,191,225"/>
+<area shape="rect" href="classsigc_1_1const__mem__functor0.html" title="const_mem_functor0 wraps const methods with 0 argument(s)." alt="" coords="5,80,199,121"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="32,5,172,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a12ae83ad7820bd716ed8a07484a339d9"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html#a12ae83ad7820bd716ed8a07484a339d9">function_type</a></td></tr>
+<tr class="separator:a12ae83ad7820bd716ed8a07484a339d9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1const__mem__functor0"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1const__mem__functor0')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1const__mem__functor0.html">sigc::const_mem_functor0< T_return, T_obj ></a></td></tr>
+<tr class="memitem:a5b768319ee81e2aa9e96a900e5e64996 inherit pub_types_classsigc_1_1const__mem__functor0"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor0.html#a5b768319ee81e2aa9e96a900e5e64996">function_type</a>) () const</td></tr>
+<tr class="separator:a5b768319ee81e2aa9e96a900e5e64996 inherit pub_types_classsigc_1_1const__mem__functor0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a553cd4d85524b5deea445b67773527bf inherit pub_types_classsigc_1_1const__mem__functor0"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor0.html#a553cd4d85524b5deea445b67773527bf">result_type</a></td></tr>
+<tr class="separator:a553cd4d85524b5deea445b67773527bf inherit pub_types_classsigc_1_1const__mem__functor0"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a44aeae8d1432f66fce9cd385094b78fa"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html#a44aeae8d1432f66fce9cd385094b78fa">bound_const_mem_functor0</a> (const T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__const__mem__functor0.html#a12ae83ad7820bd716ed8a07484a339d9">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a44aeae8d1432f66fce9cd385094b78fa"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor0.html" title="bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance.">bound_const_mem_functor0</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__mem__functor0.html#a44aeae8d1432f66fce9cd385094b78fa">More...</a><br /></td></tr>
+<tr class="separator:a44aeae8d1432f66fce9cd385094b78fa"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a67756fc7a32eb42309a1d55aea2eeb19"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html#a67756fc7a32eb42309a1d55aea2eeb19">bound_const_mem_functor0</a> (const T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__const__mem__functor0.html#a12ae83ad7820bd716ed8a07484a339d9">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a67756fc7a32eb42309a1d55aea2eeb19"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor0.html" title="bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance.">bound_const_mem_functor0</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__mem__functor0.html#a67756fc7a32eb42309a1d55aea2eeb19">More...</a><br /></td></tr>
+<tr class="separator:a67756fc7a32eb42309a1d55aea2eeb19"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7949abb2e0a675ab7faccf4b0c2b5480"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html#a7949abb2e0a675ab7faccf4b0c2b5480">operator()</a> () const</td></tr>
+<tr class="memdesc:a7949abb2e0a675ab7faccf4b0c2b5480"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__const__mem__functor0.html#a7949abb2e0a675ab7faccf4b0c2b5480">More...</a><br /></td></tr>
+<tr class="separator:a7949abb2e0a675ab7faccf4b0c2b5480"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1const__mem__functor0"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1const__mem__functor0')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1const__mem__functor0.html">sigc::const_mem_functor0< T_return, T_obj ></a></td></tr>
+<tr class="memitem:a49bba4c8045b8b6933b8f5a854ac98d6 inherit pub_methods_classsigc_1_1const__mem__functor0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor0.html#a49bba4c8045b8b6933b8f5a854ac98d6">const_mem_functor0</a> ()</td></tr>
+<tr class="memdesc:a49bba4c8045b8b6933b8f5a854ac98d6 inherit pub_methods_classsigc_1_1const__mem__functor0"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__mem__functor0.html#a49bba4c8045b8b6933b8f5a854ac98d6">More...</a><br /></td></tr>
+<tr class="separator:a49bba4c8045b8b6933b8f5a854ac98d6 inherit pub_methods_classsigc_1_1const__mem__functor0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a27895e58972642453f7b853f25a66f42 inherit pub_methods_classsigc_1_1const__mem__functor0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor0.html#a27895e58972642453f7b853f25a66f42">const_mem_functor0</a> (<a class="el" href="classsigc_1_1const__mem__functor0.html#a5b768319ee81e2aa9e96a900e5e64996">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a27895e58972642453f7b853f25a66f42 inherit pub_methods_classsigc_1_1const__mem__functor0"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__mem__functor0.html" title="const_mem_functor0 wraps const methods with 0 argument(s).">const_mem_functor0</a> object that wraps the passed method. <a href="classsigc_1_1const__mem__functor0.html#a27895e58972642453f7b853f25a66f42">More...</a><br /></td></tr>
+<tr class="separator:a27895e58972642453f7b853f25a66f42 inherit pub_methods_classsigc_1_1const__mem__functor0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac388853f99f074e549c8784d1a38f46b inherit pub_methods_classsigc_1_1const__mem__functor0"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor0.html#ac388853f99f074e549c8784d1a38f46b">operator()</a> (const T_obj & _A_obj) const</td></tr>
+<tr class="memdesc:ac388853f99f074e549c8784d1a38f46b inherit pub_methods_classsigc_1_1const__mem__functor0"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor0.html#ac388853f99f074e549c8784d1a38f46b">More...</a><br /></td></tr>
+<tr class="separator:ac388853f99f074e549c8784d1a38f46b inherit pub_methods_classsigc_1_1const__mem__functor0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abcc08c39943577648dac107692e5b34a inherit pub_methods_classsigc_1_1const__mem__functor0"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor0.html#abcc08c39943577648dac107692e5b34a">operator()</a> (const T_obj * _A_obj) const</td></tr>
+<tr class="memdesc:abcc08c39943577648dac107692e5b34a inherit pub_methods_classsigc_1_1const__mem__functor0"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor0.html#abcc08c39943577648dac107692e5b34a">More...</a><br /></td></tr>
+<tr class="separator:abcc08c39943577648dac107692e5b34a inherit pub_methods_classsigc_1_1const__mem__functor0"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:afe36947825350dc17d7fed286f57c32a"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__limit__reference.html">const_limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html#afe36947825350dc17d7fed286f57c32a">obj_</a></td></tr>
+<tr class="separator:afe36947825350dc17d7fed286f57c32a"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1const__mem__functor0"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1const__mem__functor0')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1const__mem__functor0.html">sigc::const_mem_functor0< T_return, T_obj ></a></td></tr>
+<tr class="memitem:a215359b20450c2afe93496826ac45c1d inherit pro_attribs_classsigc_1_1const__mem__functor0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor0.html#a5b768319ee81e2aa9e96a900e5e64996">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor0.html#a215359b20450c2afe93496826ac45c1d">func_ptr_</a></td></tr>
+<tr class="separator:a215359b20450c2afe93496826ac45c1d inherit pro_attribs_classsigc_1_1const__mem__functor0"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj><br />
+class sigc::bound_const_mem_functor0< T_return, T_obj ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__const__mem__functor0.html" title="bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance.">bound_const_mem_functor0</a> encapsulates a const method with 0 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__const__mem__functor0.html" title="bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance.">bound_const_mem_functor0</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__const__mem__functor0.html#a7949abb2e0a675ab7faccf4b0c2b5480" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a12ae83ad7820bd716ed8a07484a339d9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a12ae83ad7820bd716ed8a07484a339d9">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__const__mem__functor0.html">sigc::bound_const_mem_functor0</a>< T_return, T_obj >::<a class="el" href="classsigc_1_1bound__const__mem__functor0.html#a12ae83ad7820bd716ed8a07484a339d9">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a67756fc7a32eb42309a1d55aea2eeb19"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a67756fc7a32eb42309a1d55aea2eeb19">◆ </a></span>bound_const_mem_functor0() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html">sigc::bound_const_mem_functor0</a>< T_return, T_obj >::<a class="el" href="classsigc_1_1bound__const__mem__functor0.html">bound_const_mem_functor0</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html#a12ae83ad7820bd716ed8a07484a339d9">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor0.html" title="bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance.">bound_const_mem_functor0</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000170">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__mem__functor0.html#a7949abb2e0a675ab7faccf4b0c2b5480" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a44aeae8d1432f66fce9cd385094b78fa"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a44aeae8d1432f66fce9cd385094b78fa">◆ </a></span>bound_const_mem_functor0() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html">sigc::bound_const_mem_functor0</a>< T_return, T_obj >::<a class="el" href="classsigc_1_1bound__const__mem__functor0.html">bound_const_mem_functor0</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html#a12ae83ad7820bd716ed8a07484a339d9">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor0.html" title="bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance.">bound_const_mem_functor0</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__mem__functor0.html#a7949abb2e0a675ab7faccf4b0c2b5480" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a7949abb2e0a675ab7faccf4b0c2b5480"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7949abb2e0a675ab7faccf4b0c2b5480">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__const__mem__functor0.html">sigc::bound_const_mem_functor0</a>< T_return, T_obj >::operator() </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="afe36947825350dc17d7fed286f57c32a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#afe36947825350dc17d7fed286f57c32a">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__limit__reference.html">const_limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__const__mem__functor0.html">sigc::bound_const_mem_functor0</a>< T_return, T_obj >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_const_mem_functor0< T_return, T_obj >" name="sigc::bound_const_mem_functor0< T_return, T_obj >">
+<area shape="rect" id="node1" title="bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance." alt="" coords="13,169,191,225"/>
+<area shape="rect" id="node2" href="$classsigc_1_1const__mem__functor0.html" title="const_mem_functor0 wraps const methods with 0 argument(s)." alt="" coords="5,80,199,121"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="32,5,172,32"/>
+</map>
--- /dev/null
+9eff56914598f0aec33280358b12d0ee
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html">bound_const_mem_functor1</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_const_mem_functor1< T_return, T_obj, T_arg1 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__const__mem__functor1.html">sigc::bound_const_mem_functor1< T_return, T_obj, T_arg1 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html#aca80f40c27a3346521ffee81ba79da77">bound_const_mem_functor1</a>(const T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html">sigc::bound_const_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html#af62c239e5612df1b7c4c91a52a2e0c62">bound_const_mem_functor1</a>(const T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html">sigc::bound_const_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor1.html#a2c171737e0c7dc6ae00f73f1580a976d">const_mem_functor1</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor1.html">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor1.html#aba30421222bd496f9dec9b733fe70447">const_mem_functor1</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor1.html">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor1.html#af791174008d5b58aa0f4fb42a531cc4a">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor1.html">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html#a65f0cde178bdd7a26fe687a8748dac4e">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html">sigc::bound_const_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html#ac4141561bf43206a396d082dd0089fb2">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html">sigc::bound_const_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html#a4ba51a05a053caf20d9306efb0f05791">operator()</a>(type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html">sigc::bound_const_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor1.html#a9e549ccae24d5a7d1741f17c09db7d5f">sigc::const_mem_functor1::operator()</a>(const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor1.html">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor1.html#a3a575262ae2d62c39c52280017956a95">sigc::const_mem_functor1::operator()</a>(const T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor1.html">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor1.html#a8ba6a6565b8a29812e266aa4e5261a2d">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor1.html">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_const_mem_functor1< T_return, T_obj, T_arg1 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html">bound_const_mem_functor1</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__const__mem__functor1-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_const_mem_functor1< T_return, T_obj, T_arg1 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__const__mem__functor1.html" title="bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance.">bound_const_mem_functor1</a> encapsulates a const method with 1 arguments and an object instance.
+ <a href="classsigc_1_1bound__const__mem__functor1.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_const_mem_functor1< T_return, T_obj, T_arg1 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__const__mem__functor1__inherit__graph.png" border="0" usemap="#asigc_1_1bound__const__mem__functor1_3_01T__return_00_01T__obj_00_01T__arg1_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__const__mem__functor1_3_01T__return_00_01T__obj_00_01T__arg1_01_4_inherit__map" id="asigc_1_1bound__const__mem__functor1_3_01T__return_00_01T__obj_00_01T__arg1_01_4_inherit__map">
+<area shape="rect" title="bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance." alt="" coords="17,169,195,225"/>
+<area shape="rect" href="classsigc_1_1const__mem__functor1.html" title="const_mem_functor1 wraps const methods with 1 argument(s)." alt="" coords="5,80,207,121"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="36,5,176,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a65f0cde178bdd7a26fe687a8748dac4e"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html#a65f0cde178bdd7a26fe687a8748dac4e">function_type</a></td></tr>
+<tr class="separator:a65f0cde178bdd7a26fe687a8748dac4e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1const__mem__functor1"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1const__mem__functor1')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1const__mem__functor1.html">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a></td></tr>
+<tr class="memitem:a14e585a05b63c5e4790b3de75cb18c96 inherit pub_types_classsigc_1_1const__mem__functor1"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor1.html#a14e585a05b63c5e4790b3de75cb18c96">function_type</a>) (T_arg1) const</td></tr>
+<tr class="separator:a14e585a05b63c5e4790b3de75cb18c96 inherit pub_types_classsigc_1_1const__mem__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8ba6a6565b8a29812e266aa4e5261a2d inherit pub_types_classsigc_1_1const__mem__functor1"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor1.html#a8ba6a6565b8a29812e266aa4e5261a2d">result_type</a></td></tr>
+<tr class="separator:a8ba6a6565b8a29812e266aa4e5261a2d inherit pub_types_classsigc_1_1const__mem__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:af62c239e5612df1b7c4c91a52a2e0c62"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html#af62c239e5612df1b7c4c91a52a2e0c62">bound_const_mem_functor1</a> (const T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__const__mem__functor1.html#a65f0cde178bdd7a26fe687a8748dac4e">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:af62c239e5612df1b7c4c91a52a2e0c62"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor1.html" title="bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance.">bound_const_mem_functor1</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__mem__functor1.html#af62c239e5612df1b7c4c91a52a2e0c62">More...</a><br /></td></tr>
+<tr class="separator:af62c239e5612df1b7c4c91a52a2e0c62"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aca80f40c27a3346521ffee81ba79da77"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html#aca80f40c27a3346521ffee81ba79da77">bound_const_mem_functor1</a> (const T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__const__mem__functor1.html#a65f0cde178bdd7a26fe687a8748dac4e">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:aca80f40c27a3346521ffee81ba79da77"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor1.html" title="bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance.">bound_const_mem_functor1</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__mem__functor1.html#aca80f40c27a3346521ffee81ba79da77">More...</a><br /></td></tr>
+<tr class="separator:aca80f40c27a3346521ffee81ba79da77"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4ba51a05a053caf20d9306efb0f05791"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html#a4ba51a05a053caf20d9306efb0f05791">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a4ba51a05a053caf20d9306efb0f05791"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__const__mem__functor1.html#a4ba51a05a053caf20d9306efb0f05791">More...</a><br /></td></tr>
+<tr class="separator:a4ba51a05a053caf20d9306efb0f05791"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1const__mem__functor1"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1const__mem__functor1')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1const__mem__functor1.html">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a></td></tr>
+<tr class="memitem:a2c171737e0c7dc6ae00f73f1580a976d inherit pub_methods_classsigc_1_1const__mem__functor1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor1.html#a2c171737e0c7dc6ae00f73f1580a976d">const_mem_functor1</a> ()</td></tr>
+<tr class="memdesc:a2c171737e0c7dc6ae00f73f1580a976d inherit pub_methods_classsigc_1_1const__mem__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__mem__functor1.html#a2c171737e0c7dc6ae00f73f1580a976d">More...</a><br /></td></tr>
+<tr class="separator:a2c171737e0c7dc6ae00f73f1580a976d inherit pub_methods_classsigc_1_1const__mem__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba30421222bd496f9dec9b733fe70447 inherit pub_methods_classsigc_1_1const__mem__functor1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor1.html#aba30421222bd496f9dec9b733fe70447">const_mem_functor1</a> (<a class="el" href="classsigc_1_1const__mem__functor1.html#a14e585a05b63c5e4790b3de75cb18c96">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:aba30421222bd496f9dec9b733fe70447 inherit pub_methods_classsigc_1_1const__mem__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__mem__functor1.html" title="const_mem_functor1 wraps const methods with 1 argument(s).">const_mem_functor1</a> object that wraps the passed method. <a href="classsigc_1_1const__mem__functor1.html#aba30421222bd496f9dec9b733fe70447">More...</a><br /></td></tr>
+<tr class="separator:aba30421222bd496f9dec9b733fe70447 inherit pub_methods_classsigc_1_1const__mem__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3a575262ae2d62c39c52280017956a95 inherit pub_methods_classsigc_1_1const__mem__functor1"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor1.html#a3a575262ae2d62c39c52280017956a95">operator()</a> (const T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a3a575262ae2d62c39c52280017956a95 inherit pub_methods_classsigc_1_1const__mem__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor1.html#a3a575262ae2d62c39c52280017956a95">More...</a><br /></td></tr>
+<tr class="separator:a3a575262ae2d62c39c52280017956a95 inherit pub_methods_classsigc_1_1const__mem__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9e549ccae24d5a7d1741f17c09db7d5f inherit pub_methods_classsigc_1_1const__mem__functor1"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor1.html#a9e549ccae24d5a7d1741f17c09db7d5f">operator()</a> (const T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a9e549ccae24d5a7d1741f17c09db7d5f inherit pub_methods_classsigc_1_1const__mem__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor1.html#a9e549ccae24d5a7d1741f17c09db7d5f">More...</a><br /></td></tr>
+<tr class="separator:a9e549ccae24d5a7d1741f17c09db7d5f inherit pub_methods_classsigc_1_1const__mem__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:ac4141561bf43206a396d082dd0089fb2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__limit__reference.html">const_limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html#ac4141561bf43206a396d082dd0089fb2">obj_</a></td></tr>
+<tr class="separator:ac4141561bf43206a396d082dd0089fb2"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1const__mem__functor1"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1const__mem__functor1')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1const__mem__functor1.html">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a></td></tr>
+<tr class="memitem:af791174008d5b58aa0f4fb42a531cc4a inherit pro_attribs_classsigc_1_1const__mem__functor1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor1.html#a14e585a05b63c5e4790b3de75cb18c96">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor1.html#af791174008d5b58aa0f4fb42a531cc4a">func_ptr_</a></td></tr>
+<tr class="separator:af791174008d5b58aa0f4fb42a531cc4a inherit pro_attribs_classsigc_1_1const__mem__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1><br />
+class sigc::bound_const_mem_functor1< T_return, T_obj, T_arg1 ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__const__mem__functor1.html" title="bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance.">bound_const_mem_functor1</a> encapsulates a const method with 1 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__const__mem__functor1.html" title="bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance.">bound_const_mem_functor1</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__mem__functor1.html#a4ba51a05a053caf20d9306efb0f05791" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__const__mem__functor1.html#a4ba51a05a053caf20d9306efb0f05791" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a65f0cde178bdd7a26fe687a8748dac4e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a65f0cde178bdd7a26fe687a8748dac4e">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__const__mem__functor1.html">sigc::bound_const_mem_functor1</a>< T_return, T_obj, T_arg1 >::<a class="el" href="classsigc_1_1bound__const__mem__functor1.html#a65f0cde178bdd7a26fe687a8748dac4e">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="aca80f40c27a3346521ffee81ba79da77"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aca80f40c27a3346521ffee81ba79da77">◆ </a></span>bound_const_mem_functor1() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html">sigc::bound_const_mem_functor1</a>< T_return, T_obj, T_arg1 >::<a class="el" href="classsigc_1_1bound__const__mem__functor1.html">bound_const_mem_functor1</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html#a65f0cde178bdd7a26fe687a8748dac4e">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor1.html" title="bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance.">bound_const_mem_functor1</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000171">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__mem__functor1.html#a4ba51a05a053caf20d9306efb0f05791" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="af62c239e5612df1b7c4c91a52a2e0c62"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af62c239e5612df1b7c4c91a52a2e0c62">◆ </a></span>bound_const_mem_functor1() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html">sigc::bound_const_mem_functor1</a>< T_return, T_obj, T_arg1 >::<a class="el" href="classsigc_1_1bound__const__mem__functor1.html">bound_const_mem_functor1</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html#a65f0cde178bdd7a26fe687a8748dac4e">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor1.html" title="bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance.">bound_const_mem_functor1</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__mem__functor1.html#a4ba51a05a053caf20d9306efb0f05791" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a4ba51a05a053caf20d9306efb0f05791"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4ba51a05a053caf20d9306efb0f05791">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__const__mem__functor1.html">sigc::bound_const_mem_functor1</a>< T_return, T_obj, T_arg1 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="ac4141561bf43206a396d082dd0089fb2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac4141561bf43206a396d082dd0089fb2">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__limit__reference.html">const_limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__const__mem__functor1.html">sigc::bound_const_mem_functor1</a>< T_return, T_obj, T_arg1 >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_const_mem_functor1< T_return, T_obj, T_arg1 >" name="sigc::bound_const_mem_functor1< T_return, T_obj, T_arg1 >">
+<area shape="rect" id="node1" title="bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance." alt="" coords="17,169,195,225"/>
+<area shape="rect" id="node2" href="$classsigc_1_1const__mem__functor1.html" title="const_mem_functor1 wraps const methods with 1 argument(s)." alt="" coords="5,80,207,121"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="36,5,176,32"/>
+</map>
--- /dev/null
+c5da8c4c4306240f9c22af20f71474ff
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html">bound_const_mem_functor2</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__const__mem__functor2.html">sigc::bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html#a6732b8f5b308ff8ff1adea9e3734f4bf">bound_const_mem_functor2</a>(const T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html">sigc::bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html#ab5213783f248b53b357ea6385b7bbe7a">bound_const_mem_functor2</a>(const T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html">sigc::bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor2.html#a6265bdc51f35d8d5274bfeb8cdafc1dc">const_mem_functor2</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor2.html">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor2.html#ab281b110d1fbba86e2d58f9607d0f0c3">const_mem_functor2</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor2.html">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor2.html#a4445ff55323e94d525c1b2574ee32ddc">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor2.html">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html#abe2916ee9b6867554b48370000eb6886">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html">sigc::bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html#a3994b65f2ec0b45f5b502f07bf7baca1">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html">sigc::bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html#a00df32df2a5bafc0adb39da243ad3a3d">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html">sigc::bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor2.html#a51c12b33270c350c8988194cb29df590">sigc::const_mem_functor2::operator()</a>(const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor2.html">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor2.html#aafbf14880952214525553f4b419bf5c6">sigc::const_mem_functor2::operator()</a>(const T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor2.html">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor2.html#a5eaa5f2ab10ad755c89ff5b09c1e281d">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor2.html">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html">bound_const_mem_functor2</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__const__mem__functor2-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__const__mem__functor2.html" title="bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance.">bound_const_mem_functor2</a> encapsulates a const method with 2 arguments and an object instance.
+ <a href="classsigc_1_1bound__const__mem__functor2.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__const__mem__functor2__inherit__graph.png" border="0" usemap="#asigc_1_1bound__const__mem__functor2_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__const__mem__functor2_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_01_4_inherit__map" id="asigc_1_1bound__const__mem__functor2_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_01_4_inherit__map">
+<area shape="rect" title="bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance." alt="" coords="12,184,192,240"/>
+<area shape="rect" href="classsigc_1_1const__mem__functor2.html" title="const_mem_functor2 wraps const methods with 2 argument(s)." alt="" coords="5,80,199,136"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="32,5,172,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:abe2916ee9b6867554b48370000eb6886"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html#abe2916ee9b6867554b48370000eb6886">function_type</a></td></tr>
+<tr class="separator:abe2916ee9b6867554b48370000eb6886"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1const__mem__functor2"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1const__mem__functor2')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1const__mem__functor2.html">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td></tr>
+<tr class="memitem:a2294d014482fee6845b69ab5bc27daa9 inherit pub_types_classsigc_1_1const__mem__functor2"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor2.html#a2294d014482fee6845b69ab5bc27daa9">function_type</a>) (T_arg1, T_arg2) const</td></tr>
+<tr class="separator:a2294d014482fee6845b69ab5bc27daa9 inherit pub_types_classsigc_1_1const__mem__functor2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5eaa5f2ab10ad755c89ff5b09c1e281d inherit pub_types_classsigc_1_1const__mem__functor2"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor2.html#a5eaa5f2ab10ad755c89ff5b09c1e281d">result_type</a></td></tr>
+<tr class="separator:a5eaa5f2ab10ad755c89ff5b09c1e281d inherit pub_types_classsigc_1_1const__mem__functor2"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:ab5213783f248b53b357ea6385b7bbe7a"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html#ab5213783f248b53b357ea6385b7bbe7a">bound_const_mem_functor2</a> (const T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__const__mem__functor2.html#abe2916ee9b6867554b48370000eb6886">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:ab5213783f248b53b357ea6385b7bbe7a"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor2.html" title="bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance.">bound_const_mem_functor2</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__mem__functor2.html#ab5213783f248b53b357ea6385b7bbe7a">More...</a><br /></td></tr>
+<tr class="separator:ab5213783f248b53b357ea6385b7bbe7a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a6732b8f5b308ff8ff1adea9e3734f4bf"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html#a6732b8f5b308ff8ff1adea9e3734f4bf">bound_const_mem_functor2</a> (const T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__const__mem__functor2.html#abe2916ee9b6867554b48370000eb6886">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a6732b8f5b308ff8ff1adea9e3734f4bf"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor2.html" title="bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance.">bound_const_mem_functor2</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__mem__functor2.html#a6732b8f5b308ff8ff1adea9e3734f4bf">More...</a><br /></td></tr>
+<tr class="separator:a6732b8f5b308ff8ff1adea9e3734f4bf"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a00df32df2a5bafc0adb39da243ad3a3d"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html#a00df32df2a5bafc0adb39da243ad3a3d">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:a00df32df2a5bafc0adb39da243ad3a3d"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__const__mem__functor2.html#a00df32df2a5bafc0adb39da243ad3a3d">More...</a><br /></td></tr>
+<tr class="separator:a00df32df2a5bafc0adb39da243ad3a3d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1const__mem__functor2"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1const__mem__functor2')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1const__mem__functor2.html">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td></tr>
+<tr class="memitem:a6265bdc51f35d8d5274bfeb8cdafc1dc inherit pub_methods_classsigc_1_1const__mem__functor2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor2.html#a6265bdc51f35d8d5274bfeb8cdafc1dc">const_mem_functor2</a> ()</td></tr>
+<tr class="memdesc:a6265bdc51f35d8d5274bfeb8cdafc1dc inherit pub_methods_classsigc_1_1const__mem__functor2"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__mem__functor2.html#a6265bdc51f35d8d5274bfeb8cdafc1dc">More...</a><br /></td></tr>
+<tr class="separator:a6265bdc51f35d8d5274bfeb8cdafc1dc inherit pub_methods_classsigc_1_1const__mem__functor2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab281b110d1fbba86e2d58f9607d0f0c3 inherit pub_methods_classsigc_1_1const__mem__functor2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor2.html#ab281b110d1fbba86e2d58f9607d0f0c3">const_mem_functor2</a> (<a class="el" href="classsigc_1_1const__mem__functor2.html#a2294d014482fee6845b69ab5bc27daa9">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:ab281b110d1fbba86e2d58f9607d0f0c3 inherit pub_methods_classsigc_1_1const__mem__functor2"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__mem__functor2.html" title="const_mem_functor2 wraps const methods with 2 argument(s).">const_mem_functor2</a> object that wraps the passed method. <a href="classsigc_1_1const__mem__functor2.html#ab281b110d1fbba86e2d58f9607d0f0c3">More...</a><br /></td></tr>
+<tr class="separator:ab281b110d1fbba86e2d58f9607d0f0c3 inherit pub_methods_classsigc_1_1const__mem__functor2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aafbf14880952214525553f4b419bf5c6 inherit pub_methods_classsigc_1_1const__mem__functor2"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor2.html#aafbf14880952214525553f4b419bf5c6">operator()</a> (const T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:aafbf14880952214525553f4b419bf5c6 inherit pub_methods_classsigc_1_1const__mem__functor2"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor2.html#aafbf14880952214525553f4b419bf5c6">More...</a><br /></td></tr>
+<tr class="separator:aafbf14880952214525553f4b419bf5c6 inherit pub_methods_classsigc_1_1const__mem__functor2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a51c12b33270c350c8988194cb29df590 inherit pub_methods_classsigc_1_1const__mem__functor2"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor2.html#a51c12b33270c350c8988194cb29df590">operator()</a> (const T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:a51c12b33270c350c8988194cb29df590 inherit pub_methods_classsigc_1_1const__mem__functor2"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor2.html#a51c12b33270c350c8988194cb29df590">More...</a><br /></td></tr>
+<tr class="separator:a51c12b33270c350c8988194cb29df590 inherit pub_methods_classsigc_1_1const__mem__functor2"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:a3994b65f2ec0b45f5b502f07bf7baca1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__limit__reference.html">const_limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html#a3994b65f2ec0b45f5b502f07bf7baca1">obj_</a></td></tr>
+<tr class="separator:a3994b65f2ec0b45f5b502f07bf7baca1"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1const__mem__functor2"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1const__mem__functor2')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1const__mem__functor2.html">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td></tr>
+<tr class="memitem:a4445ff55323e94d525c1b2574ee32ddc inherit pro_attribs_classsigc_1_1const__mem__functor2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor2.html#a2294d014482fee6845b69ab5bc27daa9">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor2.html#a4445ff55323e94d525c1b2574ee32ddc">func_ptr_</a></td></tr>
+<tr class="separator:a4445ff55323e94d525c1b2574ee32ddc inherit pro_attribs_classsigc_1_1const__mem__functor2"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2><br />
+class sigc::bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__const__mem__functor2.html" title="bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance.">bound_const_mem_functor2</a> encapsulates a const method with 2 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__const__mem__functor2.html" title="bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance.">bound_const_mem_functor2</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__mem__functor2.html#a00df32df2a5bafc0adb39da243ad3a3d" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__mem__functor2.html#a00df32df2a5bafc0adb39da243ad3a3d" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__const__mem__functor2.html#a00df32df2a5bafc0adb39da243ad3a3d" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="abe2916ee9b6867554b48370000eb6886"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abe2916ee9b6867554b48370000eb6886">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__const__mem__functor2.html">sigc::bound_const_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1bound__const__mem__functor2.html#abe2916ee9b6867554b48370000eb6886">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a6732b8f5b308ff8ff1adea9e3734f4bf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a6732b8f5b308ff8ff1adea9e3734f4bf">◆ </a></span>bound_const_mem_functor2() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html">sigc::bound_const_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1bound__const__mem__functor2.html">bound_const_mem_functor2</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html#abe2916ee9b6867554b48370000eb6886">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor2.html" title="bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance.">bound_const_mem_functor2</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000172">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__mem__functor2.html#a00df32df2a5bafc0adb39da243ad3a3d" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="ab5213783f248b53b357ea6385b7bbe7a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab5213783f248b53b357ea6385b7bbe7a">◆ </a></span>bound_const_mem_functor2() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html">sigc::bound_const_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1bound__const__mem__functor2.html">bound_const_mem_functor2</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html#abe2916ee9b6867554b48370000eb6886">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor2.html" title="bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance.">bound_const_mem_functor2</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__mem__functor2.html#a00df32df2a5bafc0adb39da243ad3a3d" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a00df32df2a5bafc0adb39da243ad3a3d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a00df32df2a5bafc0adb39da243ad3a3d">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__const__mem__functor2.html">sigc::bound_const_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a3994b65f2ec0b45f5b502f07bf7baca1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3994b65f2ec0b45f5b502f07bf7baca1">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__limit__reference.html">const_limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__const__mem__functor2.html">sigc::bound_const_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >" name="sigc::bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >">
+<area shape="rect" id="node1" title="bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance." alt="" coords="12,184,192,240"/>
+<area shape="rect" id="node2" href="$classsigc_1_1const__mem__functor2.html" title="const_mem_functor2 wraps const methods with 2 argument(s)." alt="" coords="5,80,199,136"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="32,5,172,32"/>
+</map>
--- /dev/null
+abc0d766dfbfa550727128bf6a1fc7a2
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html">bound_const_mem_functor3</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__const__mem__functor3.html">sigc::bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html#ae63bd158d8ce2571038d4f6382a7bc51">bound_const_mem_functor3</a>(const T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html">sigc::bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html#a7fa6101b1b387baac23a7861e2819ad9">bound_const_mem_functor3</a>(const T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html">sigc::bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor3.html#a9921cf28137404e029e3f5d7c291021d">const_mem_functor3</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor3.html">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor3.html#ae70cb6e5e322ef3f3a9673b1e541d2c1">const_mem_functor3</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor3.html">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor3.html#ad86eb326f14c401748d0a118265e558d">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor3.html">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html#ab4e793d8c65bf8754aea133a2473dc6c">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html">sigc::bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html#ac4b0ceb88bda73c90d84b1320e274621">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html">sigc::bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html#aabad5390e5b2671de1b9fbba7bf1cda6">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html">sigc::bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor3.html#a6322fdc9cc492d4f3a2c8482e193540f">sigc::const_mem_functor3::operator()</a>(const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor3.html">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor3.html#aa123c4fb39116ca1a28896cfd029b1de">sigc::const_mem_functor3::operator()</a>(const T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor3.html">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor3.html#ae67fd219e64f81359640873d30123c9d">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor3.html">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html">bound_const_mem_functor3</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__const__mem__functor3-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__const__mem__functor3.html" title="bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance.">bound_const_mem_functor3</a> encapsulates a const method with 3 arguments and an object instance.
+ <a href="classsigc_1_1bound__const__mem__functor3.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__const__mem__functor3__inherit__graph.png" border="0" usemap="#asigc_1_1bound__const__mem__functor3_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__const__mem__functor3_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_01_4_inherit__map" id="asigc_1_1bound__const__mem__functor3_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_01_4_inherit__map">
+<area shape="rect" title="bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance." alt="" coords="13,184,191,255"/>
+<area shape="rect" href="classsigc_1_1const__mem__functor3.html" title="const_mem_functor3 wraps const methods with 3 argument(s)." alt="" coords="5,80,199,136"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="32,5,172,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:ab4e793d8c65bf8754aea133a2473dc6c"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html#ab4e793d8c65bf8754aea133a2473dc6c">function_type</a></td></tr>
+<tr class="separator:ab4e793d8c65bf8754aea133a2473dc6c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1const__mem__functor3"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1const__mem__functor3')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1const__mem__functor3.html">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td></tr>
+<tr class="memitem:accd266c72527ca411756bd9a4045eac9 inherit pub_types_classsigc_1_1const__mem__functor3"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor3.html#accd266c72527ca411756bd9a4045eac9">function_type</a>) (T_arg1, T_arg2, T_arg3) const</td></tr>
+<tr class="separator:accd266c72527ca411756bd9a4045eac9 inherit pub_types_classsigc_1_1const__mem__functor3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae67fd219e64f81359640873d30123c9d inherit pub_types_classsigc_1_1const__mem__functor3"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor3.html#ae67fd219e64f81359640873d30123c9d">result_type</a></td></tr>
+<tr class="separator:ae67fd219e64f81359640873d30123c9d inherit pub_types_classsigc_1_1const__mem__functor3"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a7fa6101b1b387baac23a7861e2819ad9"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html#a7fa6101b1b387baac23a7861e2819ad9">bound_const_mem_functor3</a> (const T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__const__mem__functor3.html#ab4e793d8c65bf8754aea133a2473dc6c">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a7fa6101b1b387baac23a7861e2819ad9"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor3.html" title="bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance.">bound_const_mem_functor3</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__mem__functor3.html#a7fa6101b1b387baac23a7861e2819ad9">More...</a><br /></td></tr>
+<tr class="separator:a7fa6101b1b387baac23a7861e2819ad9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae63bd158d8ce2571038d4f6382a7bc51"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html#ae63bd158d8ce2571038d4f6382a7bc51">bound_const_mem_functor3</a> (const T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__const__mem__functor3.html#ab4e793d8c65bf8754aea133a2473dc6c">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:ae63bd158d8ce2571038d4f6382a7bc51"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor3.html" title="bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance.">bound_const_mem_functor3</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__mem__functor3.html#ae63bd158d8ce2571038d4f6382a7bc51">More...</a><br /></td></tr>
+<tr class="separator:ae63bd158d8ce2571038d4f6382a7bc51"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aabad5390e5b2671de1b9fbba7bf1cda6"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html#aabad5390e5b2671de1b9fbba7bf1cda6">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:aabad5390e5b2671de1b9fbba7bf1cda6"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__const__mem__functor3.html#aabad5390e5b2671de1b9fbba7bf1cda6">More...</a><br /></td></tr>
+<tr class="separator:aabad5390e5b2671de1b9fbba7bf1cda6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1const__mem__functor3"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1const__mem__functor3')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1const__mem__functor3.html">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td></tr>
+<tr class="memitem:a9921cf28137404e029e3f5d7c291021d inherit pub_methods_classsigc_1_1const__mem__functor3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor3.html#a9921cf28137404e029e3f5d7c291021d">const_mem_functor3</a> ()</td></tr>
+<tr class="memdesc:a9921cf28137404e029e3f5d7c291021d inherit pub_methods_classsigc_1_1const__mem__functor3"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__mem__functor3.html#a9921cf28137404e029e3f5d7c291021d">More...</a><br /></td></tr>
+<tr class="separator:a9921cf28137404e029e3f5d7c291021d inherit pub_methods_classsigc_1_1const__mem__functor3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae70cb6e5e322ef3f3a9673b1e541d2c1 inherit pub_methods_classsigc_1_1const__mem__functor3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor3.html#ae70cb6e5e322ef3f3a9673b1e541d2c1">const_mem_functor3</a> (<a class="el" href="classsigc_1_1const__mem__functor3.html#accd266c72527ca411756bd9a4045eac9">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:ae70cb6e5e322ef3f3a9673b1e541d2c1 inherit pub_methods_classsigc_1_1const__mem__functor3"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__mem__functor3.html" title="const_mem_functor3 wraps const methods with 3 argument(s).">const_mem_functor3</a> object that wraps the passed method. <a href="classsigc_1_1const__mem__functor3.html#ae70cb6e5e322ef3f3a9673b1e541d2c1">More...</a><br /></td></tr>
+<tr class="separator:ae70cb6e5e322ef3f3a9673b1e541d2c1 inherit pub_methods_classsigc_1_1const__mem__functor3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa123c4fb39116ca1a28896cfd029b1de inherit pub_methods_classsigc_1_1const__mem__functor3"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor3.html#aa123c4fb39116ca1a28896cfd029b1de">operator()</a> (const T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:aa123c4fb39116ca1a28896cfd029b1de inherit pub_methods_classsigc_1_1const__mem__functor3"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor3.html#aa123c4fb39116ca1a28896cfd029b1de">More...</a><br /></td></tr>
+<tr class="separator:aa123c4fb39116ca1a28896cfd029b1de inherit pub_methods_classsigc_1_1const__mem__functor3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a6322fdc9cc492d4f3a2c8482e193540f inherit pub_methods_classsigc_1_1const__mem__functor3"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor3.html#a6322fdc9cc492d4f3a2c8482e193540f">operator()</a> (const T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:a6322fdc9cc492d4f3a2c8482e193540f inherit pub_methods_classsigc_1_1const__mem__functor3"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor3.html#a6322fdc9cc492d4f3a2c8482e193540f">More...</a><br /></td></tr>
+<tr class="separator:a6322fdc9cc492d4f3a2c8482e193540f inherit pub_methods_classsigc_1_1const__mem__functor3"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:ac4b0ceb88bda73c90d84b1320e274621"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__limit__reference.html">const_limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html#ac4b0ceb88bda73c90d84b1320e274621">obj_</a></td></tr>
+<tr class="separator:ac4b0ceb88bda73c90d84b1320e274621"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1const__mem__functor3"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1const__mem__functor3')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1const__mem__functor3.html">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td></tr>
+<tr class="memitem:ad86eb326f14c401748d0a118265e558d inherit pro_attribs_classsigc_1_1const__mem__functor3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor3.html#accd266c72527ca411756bd9a4045eac9">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor3.html#ad86eb326f14c401748d0a118265e558d">func_ptr_</a></td></tr>
+<tr class="separator:ad86eb326f14c401748d0a118265e558d inherit pro_attribs_classsigc_1_1const__mem__functor3"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3><br />
+class sigc::bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__const__mem__functor3.html" title="bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance.">bound_const_mem_functor3</a> encapsulates a const method with 3 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__const__mem__functor3.html" title="bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance.">bound_const_mem_functor3</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__mem__functor3.html#aabad5390e5b2671de1b9fbba7bf1cda6" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__mem__functor3.html#aabad5390e5b2671de1b9fbba7bf1cda6" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__mem__functor3.html#aabad5390e5b2671de1b9fbba7bf1cda6" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__const__mem__functor3.html#aabad5390e5b2671de1b9fbba7bf1cda6" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="ab4e793d8c65bf8754aea133a2473dc6c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab4e793d8c65bf8754aea133a2473dc6c">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__const__mem__functor3.html">sigc::bound_const_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1bound__const__mem__functor3.html#ab4e793d8c65bf8754aea133a2473dc6c">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="ae63bd158d8ce2571038d4f6382a7bc51"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae63bd158d8ce2571038d4f6382a7bc51">◆ </a></span>bound_const_mem_functor3() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html">sigc::bound_const_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1bound__const__mem__functor3.html">bound_const_mem_functor3</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html#ab4e793d8c65bf8754aea133a2473dc6c">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor3.html" title="bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance.">bound_const_mem_functor3</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000173">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__mem__functor3.html#aabad5390e5b2671de1b9fbba7bf1cda6" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a7fa6101b1b387baac23a7861e2819ad9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7fa6101b1b387baac23a7861e2819ad9">◆ </a></span>bound_const_mem_functor3() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html">sigc::bound_const_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1bound__const__mem__functor3.html">bound_const_mem_functor3</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html#ab4e793d8c65bf8754aea133a2473dc6c">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor3.html" title="bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance.">bound_const_mem_functor3</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__mem__functor3.html#aabad5390e5b2671de1b9fbba7bf1cda6" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="aabad5390e5b2671de1b9fbba7bf1cda6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aabad5390e5b2671de1b9fbba7bf1cda6">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__const__mem__functor3.html">sigc::bound_const_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="ac4b0ceb88bda73c90d84b1320e274621"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac4b0ceb88bda73c90d84b1320e274621">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__limit__reference.html">const_limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__const__mem__functor3.html">sigc::bound_const_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >" name="sigc::bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >">
+<area shape="rect" id="node1" title="bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance." alt="" coords="13,184,191,255"/>
+<area shape="rect" id="node2" href="$classsigc_1_1const__mem__functor3.html" title="const_mem_functor3 wraps const methods with 3 argument(s)." alt="" coords="5,80,199,136"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="32,5,172,32"/>
+</map>
--- /dev/null
+584ec0996f7e7a2258933da8ee781ce8
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html">bound_const_mem_functor4</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__const__mem__functor4.html">sigc::bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a1d441ea8caf2d2ff8cfca414f259b657">bound_const_mem_functor4</a>(const T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html">sigc::bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a06e43c95d6ace639ac169ff2d0083ebc">bound_const_mem_functor4</a>(const T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html">sigc::bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor4.html#acdde68d1638c13cd29157d1cb1bd42d2">const_mem_functor4</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor4.html">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor4.html#a7e09703c6320542cb5f0075d371908a8">const_mem_functor4</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor4.html">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor4.html#ac0feeedacde97bd166141c285fa2c74c">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor4.html">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a3ffc5790ded15878ce2704072791c4e9">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html">sigc::bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a78490633e22357be6e0a0fcf124121b5">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html">sigc::bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a4db87f79d355f2ca4f5ff20d47c35ee3">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html">sigc::bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor4.html#a5b178876ca9fbec1fa2339819939a9e7">sigc::const_mem_functor4::operator()</a>(const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor4.html">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor4.html#a25b73f70e0cb8771a6fc8dd1ad521795">sigc::const_mem_functor4::operator()</a>(const T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor4.html">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor4.html#a78069750e64446199d91c0682b0915cc">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor4.html">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html">bound_const_mem_functor4</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__const__mem__functor4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__const__mem__functor4.html" title="bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance.">bound_const_mem_functor4</a> encapsulates a const method with 4 arguments and an object instance.
+ <a href="classsigc_1_1bound__const__mem__functor4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__const__mem__functor4__inherit__graph.png" border="0" usemap="#asigc_1_1bound__const__mem__functor4_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__const__mem__functor4_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_01_4_inherit__map" id="asigc_1_1bound__const__mem__functor4_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_01_4_inherit__map">
+<area shape="rect" title="bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance." alt="" coords="13,184,191,255"/>
+<area shape="rect" href="classsigc_1_1const__mem__functor4.html" title="const_mem_functor4 wraps const methods with 4 argument(s)." alt="" coords="5,80,199,136"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="32,5,172,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a3ffc5790ded15878ce2704072791c4e9"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a3ffc5790ded15878ce2704072791c4e9">function_type</a></td></tr>
+<tr class="separator:a3ffc5790ded15878ce2704072791c4e9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1const__mem__functor4"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1const__mem__functor4')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1const__mem__functor4.html">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td></tr>
+<tr class="memitem:a775bb61661f2a7007b36f16ee106a8ad inherit pub_types_classsigc_1_1const__mem__functor4"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor4.html#a775bb61661f2a7007b36f16ee106a8ad">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4) const</td></tr>
+<tr class="separator:a775bb61661f2a7007b36f16ee106a8ad inherit pub_types_classsigc_1_1const__mem__functor4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a78069750e64446199d91c0682b0915cc inherit pub_types_classsigc_1_1const__mem__functor4"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor4.html#a78069750e64446199d91c0682b0915cc">result_type</a></td></tr>
+<tr class="separator:a78069750e64446199d91c0682b0915cc inherit pub_types_classsigc_1_1const__mem__functor4"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a06e43c95d6ace639ac169ff2d0083ebc"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a06e43c95d6ace639ac169ff2d0083ebc">bound_const_mem_functor4</a> (const T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a3ffc5790ded15878ce2704072791c4e9">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a06e43c95d6ace639ac169ff2d0083ebc"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor4.html" title="bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance.">bound_const_mem_functor4</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__mem__functor4.html#a06e43c95d6ace639ac169ff2d0083ebc">More...</a><br /></td></tr>
+<tr class="separator:a06e43c95d6ace639ac169ff2d0083ebc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1d441ea8caf2d2ff8cfca414f259b657"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a1d441ea8caf2d2ff8cfca414f259b657">bound_const_mem_functor4</a> (const T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a3ffc5790ded15878ce2704072791c4e9">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a1d441ea8caf2d2ff8cfca414f259b657"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor4.html" title="bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance.">bound_const_mem_functor4</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__mem__functor4.html#a1d441ea8caf2d2ff8cfca414f259b657">More...</a><br /></td></tr>
+<tr class="separator:a1d441ea8caf2d2ff8cfca414f259b657"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4db87f79d355f2ca4f5ff20d47c35ee3"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a4db87f79d355f2ca4f5ff20d47c35ee3">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:a4db87f79d355f2ca4f5ff20d47c35ee3"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__const__mem__functor4.html#a4db87f79d355f2ca4f5ff20d47c35ee3">More...</a><br /></td></tr>
+<tr class="separator:a4db87f79d355f2ca4f5ff20d47c35ee3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1const__mem__functor4"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1const__mem__functor4')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1const__mem__functor4.html">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td></tr>
+<tr class="memitem:acdde68d1638c13cd29157d1cb1bd42d2 inherit pub_methods_classsigc_1_1const__mem__functor4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor4.html#acdde68d1638c13cd29157d1cb1bd42d2">const_mem_functor4</a> ()</td></tr>
+<tr class="memdesc:acdde68d1638c13cd29157d1cb1bd42d2 inherit pub_methods_classsigc_1_1const__mem__functor4"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__mem__functor4.html#acdde68d1638c13cd29157d1cb1bd42d2">More...</a><br /></td></tr>
+<tr class="separator:acdde68d1638c13cd29157d1cb1bd42d2 inherit pub_methods_classsigc_1_1const__mem__functor4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7e09703c6320542cb5f0075d371908a8 inherit pub_methods_classsigc_1_1const__mem__functor4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor4.html#a7e09703c6320542cb5f0075d371908a8">const_mem_functor4</a> (<a class="el" href="classsigc_1_1const__mem__functor4.html#a775bb61661f2a7007b36f16ee106a8ad">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a7e09703c6320542cb5f0075d371908a8 inherit pub_methods_classsigc_1_1const__mem__functor4"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__mem__functor4.html" title="const_mem_functor4 wraps const methods with 4 argument(s).">const_mem_functor4</a> object that wraps the passed method. <a href="classsigc_1_1const__mem__functor4.html#a7e09703c6320542cb5f0075d371908a8">More...</a><br /></td></tr>
+<tr class="separator:a7e09703c6320542cb5f0075d371908a8 inherit pub_methods_classsigc_1_1const__mem__functor4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a25b73f70e0cb8771a6fc8dd1ad521795 inherit pub_methods_classsigc_1_1const__mem__functor4"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor4.html#a25b73f70e0cb8771a6fc8dd1ad521795">operator()</a> (const T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:a25b73f70e0cb8771a6fc8dd1ad521795 inherit pub_methods_classsigc_1_1const__mem__functor4"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor4.html#a25b73f70e0cb8771a6fc8dd1ad521795">More...</a><br /></td></tr>
+<tr class="separator:a25b73f70e0cb8771a6fc8dd1ad521795 inherit pub_methods_classsigc_1_1const__mem__functor4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5b178876ca9fbec1fa2339819939a9e7 inherit pub_methods_classsigc_1_1const__mem__functor4"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor4.html#a5b178876ca9fbec1fa2339819939a9e7">operator()</a> (const T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:a5b178876ca9fbec1fa2339819939a9e7 inherit pub_methods_classsigc_1_1const__mem__functor4"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor4.html#a5b178876ca9fbec1fa2339819939a9e7">More...</a><br /></td></tr>
+<tr class="separator:a5b178876ca9fbec1fa2339819939a9e7 inherit pub_methods_classsigc_1_1const__mem__functor4"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:a78490633e22357be6e0a0fcf124121b5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__limit__reference.html">const_limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a78490633e22357be6e0a0fcf124121b5">obj_</a></td></tr>
+<tr class="separator:a78490633e22357be6e0a0fcf124121b5"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1const__mem__functor4"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1const__mem__functor4')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1const__mem__functor4.html">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td></tr>
+<tr class="memitem:ac0feeedacde97bd166141c285fa2c74c inherit pro_attribs_classsigc_1_1const__mem__functor4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor4.html#a775bb61661f2a7007b36f16ee106a8ad">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor4.html#ac0feeedacde97bd166141c285fa2c74c">func_ptr_</a></td></tr>
+<tr class="separator:ac0feeedacde97bd166141c285fa2c74c inherit pro_attribs_classsigc_1_1const__mem__functor4"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4><br />
+class sigc::bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__const__mem__functor4.html" title="bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance.">bound_const_mem_functor4</a> encapsulates a const method with 4 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__const__mem__functor4.html" title="bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance.">bound_const_mem_functor4</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a4db87f79d355f2ca4f5ff20d47c35ee3" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a4db87f79d355f2ca4f5ff20d47c35ee3" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a4db87f79d355f2ca4f5ff20d47c35ee3" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a4db87f79d355f2ca4f5ff20d47c35ee3" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a4db87f79d355f2ca4f5ff20d47c35ee3" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a3ffc5790ded15878ce2704072791c4e9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3ffc5790ded15878ce2704072791c4e9">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__const__mem__functor4.html">sigc::bound_const_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a3ffc5790ded15878ce2704072791c4e9">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a1d441ea8caf2d2ff8cfca414f259b657"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1d441ea8caf2d2ff8cfca414f259b657">◆ </a></span>bound_const_mem_functor4() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html">sigc::bound_const_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1bound__const__mem__functor4.html">bound_const_mem_functor4</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a3ffc5790ded15878ce2704072791c4e9">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor4.html" title="bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance.">bound_const_mem_functor4</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000174">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a4db87f79d355f2ca4f5ff20d47c35ee3" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a06e43c95d6ace639ac169ff2d0083ebc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a06e43c95d6ace639ac169ff2d0083ebc">◆ </a></span>bound_const_mem_functor4() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html">sigc::bound_const_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1bound__const__mem__functor4.html">bound_const_mem_functor4</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a3ffc5790ded15878ce2704072791c4e9">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor4.html" title="bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance.">bound_const_mem_functor4</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a4db87f79d355f2ca4f5ff20d47c35ee3" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a4db87f79d355f2ca4f5ff20d47c35ee3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4db87f79d355f2ca4f5ff20d47c35ee3">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__const__mem__functor4.html">sigc::bound_const_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a78490633e22357be6e0a0fcf124121b5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a78490633e22357be6e0a0fcf124121b5">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__limit__reference.html">const_limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__const__mem__functor4.html">sigc::bound_const_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >" name="sigc::bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >">
+<area shape="rect" id="node1" title="bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance." alt="" coords="13,184,191,255"/>
+<area shape="rect" id="node2" href="$classsigc_1_1const__mem__functor4.html" title="const_mem_functor4 wraps const methods with 4 argument(s)." alt="" coords="5,80,199,136"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="32,5,172,32"/>
+</map>
--- /dev/null
+592b3e764e0d5475c7d5738caebde4dd
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html">bound_const_mem_functor5</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__const__mem__functor5.html">sigc::bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a9e80ad7a6b586eb1d0cc0a4afc9ea1d4">bound_const_mem_functor5</a>(const T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html">sigc::bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a3c8a1d1411eea1136fa273886688290d">bound_const_mem_functor5</a>(const T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html">sigc::bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor5.html#a818da40f7c82d6a1fde3009d32bf3920">const_mem_functor5</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor5.html">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor5.html#a47769ef46d8ff779df8c152acdc0d74c">const_mem_functor5</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor5.html">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor5.html#aeb6e66e0304e5c039d97264a3dd7d6e9">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor5.html">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a882a71b51f303ded9d1ce172b522692a">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html">sigc::bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a71f8b7b3a9971d58209c3008d5e32d79">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html">sigc::bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a89a861b0925989a0e845399443eee20a">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html">sigc::bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor5.html#ae710c03998c58cb8f90ce75a46fab69c">sigc::const_mem_functor5::operator()</a>(const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor5.html">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor5.html#aaceffe6505aed22dd5af369231914965">sigc::const_mem_functor5::operator()</a>(const T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor5.html">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor5.html#a9d952d52dade789bc38953c4c83fb425">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor5.html">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html">bound_const_mem_functor5</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__const__mem__functor5-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__const__mem__functor5.html" title="bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance.">bound_const_mem_functor5</a> encapsulates a const method with 5 arguments and an object instance.
+ <a href="classsigc_1_1bound__const__mem__functor5.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__const__mem__functor5__inherit__graph.png" border="0" usemap="#asigc_1_1bound__const__mem__functor5_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__const__mem__functor5_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_01_4_inherit__map" id="asigc_1_1bound__const__mem__functor5_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_01_4_inherit__map">
+<area shape="rect" title="bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance." alt="" coords="435,5,624,76"/>
+<area shape="rect" href="classsigc_1_1const__mem__functor5.html" title="const_mem_functor5 wraps const methods with 5 argument(s)." alt="" coords="193,5,387,76"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,27,145,54"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a882a71b51f303ded9d1ce172b522692a"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a882a71b51f303ded9d1ce172b522692a">function_type</a></td></tr>
+<tr class="separator:a882a71b51f303ded9d1ce172b522692a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1const__mem__functor5"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1const__mem__functor5')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1const__mem__functor5.html">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td></tr>
+<tr class="memitem:aa58310b256b11e94d9a757acf60b410a inherit pub_types_classsigc_1_1const__mem__functor5"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor5.html#aa58310b256b11e94d9a757acf60b410a">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const</td></tr>
+<tr class="separator:aa58310b256b11e94d9a757acf60b410a inherit pub_types_classsigc_1_1const__mem__functor5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9d952d52dade789bc38953c4c83fb425 inherit pub_types_classsigc_1_1const__mem__functor5"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor5.html#a9d952d52dade789bc38953c4c83fb425">result_type</a></td></tr>
+<tr class="separator:a9d952d52dade789bc38953c4c83fb425 inherit pub_types_classsigc_1_1const__mem__functor5"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a3c8a1d1411eea1136fa273886688290d"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a3c8a1d1411eea1136fa273886688290d">bound_const_mem_functor5</a> (const T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a882a71b51f303ded9d1ce172b522692a">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a3c8a1d1411eea1136fa273886688290d"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor5.html" title="bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance.">bound_const_mem_functor5</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__mem__functor5.html#a3c8a1d1411eea1136fa273886688290d">More...</a><br /></td></tr>
+<tr class="separator:a3c8a1d1411eea1136fa273886688290d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9e80ad7a6b586eb1d0cc0a4afc9ea1d4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a9e80ad7a6b586eb1d0cc0a4afc9ea1d4">bound_const_mem_functor5</a> (const T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a882a71b51f303ded9d1ce172b522692a">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a9e80ad7a6b586eb1d0cc0a4afc9ea1d4"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor5.html" title="bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance.">bound_const_mem_functor5</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__mem__functor5.html#a9e80ad7a6b586eb1d0cc0a4afc9ea1d4">More...</a><br /></td></tr>
+<tr class="separator:a9e80ad7a6b586eb1d0cc0a4afc9ea1d4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a89a861b0925989a0e845399443eee20a"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a89a861b0925989a0e845399443eee20a">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:a89a861b0925989a0e845399443eee20a"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__const__mem__functor5.html#a89a861b0925989a0e845399443eee20a">More...</a><br /></td></tr>
+<tr class="separator:a89a861b0925989a0e845399443eee20a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1const__mem__functor5"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1const__mem__functor5')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1const__mem__functor5.html">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td></tr>
+<tr class="memitem:a818da40f7c82d6a1fde3009d32bf3920 inherit pub_methods_classsigc_1_1const__mem__functor5"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor5.html#a818da40f7c82d6a1fde3009d32bf3920">const_mem_functor5</a> ()</td></tr>
+<tr class="memdesc:a818da40f7c82d6a1fde3009d32bf3920 inherit pub_methods_classsigc_1_1const__mem__functor5"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__mem__functor5.html#a818da40f7c82d6a1fde3009d32bf3920">More...</a><br /></td></tr>
+<tr class="separator:a818da40f7c82d6a1fde3009d32bf3920 inherit pub_methods_classsigc_1_1const__mem__functor5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a47769ef46d8ff779df8c152acdc0d74c inherit pub_methods_classsigc_1_1const__mem__functor5"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor5.html#a47769ef46d8ff779df8c152acdc0d74c">const_mem_functor5</a> (<a class="el" href="classsigc_1_1const__mem__functor5.html#aa58310b256b11e94d9a757acf60b410a">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a47769ef46d8ff779df8c152acdc0d74c inherit pub_methods_classsigc_1_1const__mem__functor5"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__mem__functor5.html" title="const_mem_functor5 wraps const methods with 5 argument(s).">const_mem_functor5</a> object that wraps the passed method. <a href="classsigc_1_1const__mem__functor5.html#a47769ef46d8ff779df8c152acdc0d74c">More...</a><br /></td></tr>
+<tr class="separator:a47769ef46d8ff779df8c152acdc0d74c inherit pub_methods_classsigc_1_1const__mem__functor5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aaceffe6505aed22dd5af369231914965 inherit pub_methods_classsigc_1_1const__mem__functor5"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor5.html#aaceffe6505aed22dd5af369231914965">operator()</a> (const T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:aaceffe6505aed22dd5af369231914965 inherit pub_methods_classsigc_1_1const__mem__functor5"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor5.html#aaceffe6505aed22dd5af369231914965">More...</a><br /></td></tr>
+<tr class="separator:aaceffe6505aed22dd5af369231914965 inherit pub_methods_classsigc_1_1const__mem__functor5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae710c03998c58cb8f90ce75a46fab69c inherit pub_methods_classsigc_1_1const__mem__functor5"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor5.html#ae710c03998c58cb8f90ce75a46fab69c">operator()</a> (const T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:ae710c03998c58cb8f90ce75a46fab69c inherit pub_methods_classsigc_1_1const__mem__functor5"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor5.html#ae710c03998c58cb8f90ce75a46fab69c">More...</a><br /></td></tr>
+<tr class="separator:ae710c03998c58cb8f90ce75a46fab69c inherit pub_methods_classsigc_1_1const__mem__functor5"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:a71f8b7b3a9971d58209c3008d5e32d79"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__limit__reference.html">const_limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a71f8b7b3a9971d58209c3008d5e32d79">obj_</a></td></tr>
+<tr class="separator:a71f8b7b3a9971d58209c3008d5e32d79"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1const__mem__functor5"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1const__mem__functor5')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1const__mem__functor5.html">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td></tr>
+<tr class="memitem:aeb6e66e0304e5c039d97264a3dd7d6e9 inherit pro_attribs_classsigc_1_1const__mem__functor5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor5.html#aa58310b256b11e94d9a757acf60b410a">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor5.html#aeb6e66e0304e5c039d97264a3dd7d6e9">func_ptr_</a></td></tr>
+<tr class="separator:aeb6e66e0304e5c039d97264a3dd7d6e9 inherit pro_attribs_classsigc_1_1const__mem__functor5"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5><br />
+class sigc::bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__const__mem__functor5.html" title="bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance.">bound_const_mem_functor5</a> encapsulates a const method with 5 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__const__mem__functor5.html" title="bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance.">bound_const_mem_functor5</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a89a861b0925989a0e845399443eee20a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a89a861b0925989a0e845399443eee20a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a89a861b0925989a0e845399443eee20a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a89a861b0925989a0e845399443eee20a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a89a861b0925989a0e845399443eee20a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a89a861b0925989a0e845399443eee20a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a882a71b51f303ded9d1ce172b522692a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a882a71b51f303ded9d1ce172b522692a">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__const__mem__functor5.html">sigc::bound_const_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a882a71b51f303ded9d1ce172b522692a">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a9e80ad7a6b586eb1d0cc0a4afc9ea1d4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9e80ad7a6b586eb1d0cc0a4afc9ea1d4">◆ </a></span>bound_const_mem_functor5() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html">sigc::bound_const_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1bound__const__mem__functor5.html">bound_const_mem_functor5</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a882a71b51f303ded9d1ce172b522692a">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor5.html" title="bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance.">bound_const_mem_functor5</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000175">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a89a861b0925989a0e845399443eee20a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a3c8a1d1411eea1136fa273886688290d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3c8a1d1411eea1136fa273886688290d">◆ </a></span>bound_const_mem_functor5() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html">sigc::bound_const_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1bound__const__mem__functor5.html">bound_const_mem_functor5</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a882a71b51f303ded9d1ce172b522692a">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor5.html" title="bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance.">bound_const_mem_functor5</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a89a861b0925989a0e845399443eee20a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a89a861b0925989a0e845399443eee20a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a89a861b0925989a0e845399443eee20a">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__const__mem__functor5.html">sigc::bound_const_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a71f8b7b3a9971d58209c3008d5e32d79"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a71f8b7b3a9971d58209c3008d5e32d79">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__limit__reference.html">const_limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__const__mem__functor5.html">sigc::bound_const_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >" name="sigc::bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >">
+<area shape="rect" id="node1" title="bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance." alt="" coords="435,5,624,76"/>
+<area shape="rect" id="node2" href="$classsigc_1_1const__mem__functor5.html" title="const_mem_functor5 wraps const methods with 5 argument(s)." alt="" coords="193,5,387,76"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,27,145,54"/>
+</map>
--- /dev/null
+8a752af5f432e50fb0d98621eba7f4d6
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html">bound_const_mem_functor6</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__const__mem__functor6.html">sigc::bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a4c6a29813f84239bfc224e36d3ada58c">bound_const_mem_functor6</a>(const T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html">sigc::bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html#afa0adf0adf9cde73008982d2494f3d7e">bound_const_mem_functor6</a>(const T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html">sigc::bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor6.html#a7a5e8a3a981a615a545aab358efa9472">const_mem_functor6</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor6.html">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor6.html#a0803b89f79b60c16d87c0372be261211">const_mem_functor6</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor6.html">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor6.html#a665c77c3da00d474d6d999c394801a98">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor6.html">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a9cd70f288cac9b8d7ee9695166f3d306">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html">sigc::bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a152f10d5c46eb9d7d582a6e4cb747baf">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html">sigc::bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a6bc7018118bbf55444f4d9250cf3ce65">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html">sigc::bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor6.html#a023fd4cb845234b50c5dee1f4147cde9">sigc::const_mem_functor6::operator()</a>(const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor6.html">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor6.html#a8657b806cb2eeb7e43f0a09f6556c514">sigc::const_mem_functor6::operator()</a>(const T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor6.html">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor6.html#adf81aebfa633d0bf14a0d3f5e9688561">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor6.html">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html">bound_const_mem_functor6</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__const__mem__functor6-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__const__mem__functor6.html" title="bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance.">bound_const_mem_functor6</a> encapsulates a const method with 6 arguments and an object instance.
+ <a href="classsigc_1_1bound__const__mem__functor6.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__const__mem__functor6__inherit__graph.png" border="0" usemap="#asigc_1_1bound__const__mem__functor6_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__const__mem__functor6_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_01_4_inherit__map" id="asigc_1_1bound__const__mem__functor6_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_01_4_inherit__map">
+<area shape="rect" title="bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance." alt="" coords="435,5,613,91"/>
+<area shape="rect" href="classsigc_1_1const__mem__functor6.html" title="const_mem_functor6 wraps const methods with 6 argument(s)." alt="" coords="193,13,387,83"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,35,145,61"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a9cd70f288cac9b8d7ee9695166f3d306"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a9cd70f288cac9b8d7ee9695166f3d306">function_type</a></td></tr>
+<tr class="separator:a9cd70f288cac9b8d7ee9695166f3d306"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1const__mem__functor6"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1const__mem__functor6')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1const__mem__functor6.html">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td></tr>
+<tr class="memitem:ad64803b1192e1007887f234b8c7421ac inherit pub_types_classsigc_1_1const__mem__functor6"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor6.html#ad64803b1192e1007887f234b8c7421ac">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const</td></tr>
+<tr class="separator:ad64803b1192e1007887f234b8c7421ac inherit pub_types_classsigc_1_1const__mem__functor6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adf81aebfa633d0bf14a0d3f5e9688561 inherit pub_types_classsigc_1_1const__mem__functor6"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor6.html#adf81aebfa633d0bf14a0d3f5e9688561">result_type</a></td></tr>
+<tr class="separator:adf81aebfa633d0bf14a0d3f5e9688561 inherit pub_types_classsigc_1_1const__mem__functor6"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:afa0adf0adf9cde73008982d2494f3d7e"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html#afa0adf0adf9cde73008982d2494f3d7e">bound_const_mem_functor6</a> (const T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a9cd70f288cac9b8d7ee9695166f3d306">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:afa0adf0adf9cde73008982d2494f3d7e"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor6.html" title="bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance.">bound_const_mem_functor6</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__mem__functor6.html#afa0adf0adf9cde73008982d2494f3d7e">More...</a><br /></td></tr>
+<tr class="separator:afa0adf0adf9cde73008982d2494f3d7e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4c6a29813f84239bfc224e36d3ada58c"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a4c6a29813f84239bfc224e36d3ada58c">bound_const_mem_functor6</a> (const T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a9cd70f288cac9b8d7ee9695166f3d306">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a4c6a29813f84239bfc224e36d3ada58c"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor6.html" title="bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance.">bound_const_mem_functor6</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__mem__functor6.html#a4c6a29813f84239bfc224e36d3ada58c">More...</a><br /></td></tr>
+<tr class="separator:a4c6a29813f84239bfc224e36d3ada58c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a6bc7018118bbf55444f4d9250cf3ce65"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a6bc7018118bbf55444f4d9250cf3ce65">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:a6bc7018118bbf55444f4d9250cf3ce65"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__const__mem__functor6.html#a6bc7018118bbf55444f4d9250cf3ce65">More...</a><br /></td></tr>
+<tr class="separator:a6bc7018118bbf55444f4d9250cf3ce65"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1const__mem__functor6"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1const__mem__functor6')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1const__mem__functor6.html">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td></tr>
+<tr class="memitem:a7a5e8a3a981a615a545aab358efa9472 inherit pub_methods_classsigc_1_1const__mem__functor6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor6.html#a7a5e8a3a981a615a545aab358efa9472">const_mem_functor6</a> ()</td></tr>
+<tr class="memdesc:a7a5e8a3a981a615a545aab358efa9472 inherit pub_methods_classsigc_1_1const__mem__functor6"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__mem__functor6.html#a7a5e8a3a981a615a545aab358efa9472">More...</a><br /></td></tr>
+<tr class="separator:a7a5e8a3a981a615a545aab358efa9472 inherit pub_methods_classsigc_1_1const__mem__functor6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0803b89f79b60c16d87c0372be261211 inherit pub_methods_classsigc_1_1const__mem__functor6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor6.html#a0803b89f79b60c16d87c0372be261211">const_mem_functor6</a> (<a class="el" href="classsigc_1_1const__mem__functor6.html#ad64803b1192e1007887f234b8c7421ac">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a0803b89f79b60c16d87c0372be261211 inherit pub_methods_classsigc_1_1const__mem__functor6"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__mem__functor6.html" title="const_mem_functor6 wraps const methods with 6 argument(s).">const_mem_functor6</a> object that wraps the passed method. <a href="classsigc_1_1const__mem__functor6.html#a0803b89f79b60c16d87c0372be261211">More...</a><br /></td></tr>
+<tr class="separator:a0803b89f79b60c16d87c0372be261211 inherit pub_methods_classsigc_1_1const__mem__functor6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8657b806cb2eeb7e43f0a09f6556c514 inherit pub_methods_classsigc_1_1const__mem__functor6"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor6.html#a8657b806cb2eeb7e43f0a09f6556c514">operator()</a> (const T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:a8657b806cb2eeb7e43f0a09f6556c514 inherit pub_methods_classsigc_1_1const__mem__functor6"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor6.html#a8657b806cb2eeb7e43f0a09f6556c514">More...</a><br /></td></tr>
+<tr class="separator:a8657b806cb2eeb7e43f0a09f6556c514 inherit pub_methods_classsigc_1_1const__mem__functor6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a023fd4cb845234b50c5dee1f4147cde9 inherit pub_methods_classsigc_1_1const__mem__functor6"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor6.html#a023fd4cb845234b50c5dee1f4147cde9">operator()</a> (const T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:a023fd4cb845234b50c5dee1f4147cde9 inherit pub_methods_classsigc_1_1const__mem__functor6"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor6.html#a023fd4cb845234b50c5dee1f4147cde9">More...</a><br /></td></tr>
+<tr class="separator:a023fd4cb845234b50c5dee1f4147cde9 inherit pub_methods_classsigc_1_1const__mem__functor6"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:a152f10d5c46eb9d7d582a6e4cb747baf"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__limit__reference.html">const_limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a152f10d5c46eb9d7d582a6e4cb747baf">obj_</a></td></tr>
+<tr class="separator:a152f10d5c46eb9d7d582a6e4cb747baf"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1const__mem__functor6"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1const__mem__functor6')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1const__mem__functor6.html">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td></tr>
+<tr class="memitem:a665c77c3da00d474d6d999c394801a98 inherit pro_attribs_classsigc_1_1const__mem__functor6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor6.html#ad64803b1192e1007887f234b8c7421ac">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor6.html#a665c77c3da00d474d6d999c394801a98">func_ptr_</a></td></tr>
+<tr class="separator:a665c77c3da00d474d6d999c394801a98 inherit pro_attribs_classsigc_1_1const__mem__functor6"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6><br />
+class sigc::bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__const__mem__functor6.html" title="bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance.">bound_const_mem_functor6</a> encapsulates a const method with 6 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__const__mem__functor6.html" title="bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance.">bound_const_mem_functor6</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a6bc7018118bbf55444f4d9250cf3ce65" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a6bc7018118bbf55444f4d9250cf3ce65" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a6bc7018118bbf55444f4d9250cf3ce65" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a6bc7018118bbf55444f4d9250cf3ce65" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a6bc7018118bbf55444f4d9250cf3ce65" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg6</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a6bc7018118bbf55444f4d9250cf3ce65" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a6bc7018118bbf55444f4d9250cf3ce65" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a9cd70f288cac9b8d7ee9695166f3d306"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9cd70f288cac9b8d7ee9695166f3d306">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__const__mem__functor6.html">sigc::bound_const_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a9cd70f288cac9b8d7ee9695166f3d306">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a4c6a29813f84239bfc224e36d3ada58c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4c6a29813f84239bfc224e36d3ada58c">◆ </a></span>bound_const_mem_functor6() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html">sigc::bound_const_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1bound__const__mem__functor6.html">bound_const_mem_functor6</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a9cd70f288cac9b8d7ee9695166f3d306">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor6.html" title="bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance.">bound_const_mem_functor6</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000176">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a6bc7018118bbf55444f4d9250cf3ce65" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="afa0adf0adf9cde73008982d2494f3d7e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#afa0adf0adf9cde73008982d2494f3d7e">◆ </a></span>bound_const_mem_functor6() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html">sigc::bound_const_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1bound__const__mem__functor6.html">bound_const_mem_functor6</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a9cd70f288cac9b8d7ee9695166f3d306">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor6.html" title="bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance.">bound_const_mem_functor6</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a6bc7018118bbf55444f4d9250cf3ce65" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a6bc7018118bbf55444f4d9250cf3ce65"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a6bc7018118bbf55444f4d9250cf3ce65">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__const__mem__functor6.html">sigc::bound_const_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a152f10d5c46eb9d7d582a6e4cb747baf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a152f10d5c46eb9d7d582a6e4cb747baf">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__limit__reference.html">const_limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__const__mem__functor6.html">sigc::bound_const_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >" name="sigc::bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >">
+<area shape="rect" id="node1" title="bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance." alt="" coords="435,5,613,91"/>
+<area shape="rect" id="node2" href="$classsigc_1_1const__mem__functor6.html" title="const_mem_functor6 wraps const methods with 6 argument(s)." alt="" coords="193,13,387,83"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,35,145,61"/>
+</map>
--- /dev/null
+5c5d726a2fc89475fe622d95e884872f
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html">bound_const_mem_functor7</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__const__mem__functor7.html">sigc::bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html#a3353dd997ced3fc00f44ee2b8ccb0063">bound_const_mem_functor7</a>(const T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html">sigc::bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html#a22e365208dda5614599860d5794cb64f">bound_const_mem_functor7</a>(const T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html">sigc::bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor7.html#add4d7f74905c6bc20afc6f7681f367c0">const_mem_functor7</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor7.html">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor7.html#a0538bba01694fc13456fcee0e96d8f34">const_mem_functor7</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor7.html">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor7.html#a255588607e165db8bd25c3bb8d7e1fbe">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor7.html">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html#ae95db1c3ce4d07122e39dde2c9c5af02">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html">sigc::bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html#a2b59ccc18d96b4b2ec0f6828a5c2a6e0">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html">sigc::bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html#a941b925ad1f628cde49bb268be8daf4a">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html">sigc::bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor7.html#a53f19248e5b61460759d7cdbf41ca21b">sigc::const_mem_functor7::operator()</a>(const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor7.html">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor7.html#ab49dc9f302ef22e4b76043d9bc2f5062">sigc::const_mem_functor7::operator()</a>(const T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor7.html">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor7.html#a724b8b210493e0d3cf06b5a393b91546">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor7.html">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html">bound_const_mem_functor7</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__const__mem__functor7-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__const__mem__functor7.html" title="bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance.">bound_const_mem_functor7</a> encapsulates a const method with 7 arguments and an object instance.
+ <a href="classsigc_1_1bound__const__mem__functor7.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__const__mem__functor7__inherit__graph.png" border="0" usemap="#asigc_1_1bound__const__mem__functor7_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__const__mem__functor7_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map" id="asigc_1_1bound__const__mem__functor7_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map">
+<area shape="rect" title="bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance." alt="" coords="435,5,613,91"/>
+<area shape="rect" href="classsigc_1_1const__mem__functor7.html" title="const_mem_functor7 wraps const methods with 7 argument(s)." alt="" coords="193,13,387,83"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,35,145,61"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:ae95db1c3ce4d07122e39dde2c9c5af02"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html#ae95db1c3ce4d07122e39dde2c9c5af02">function_type</a></td></tr>
+<tr class="separator:ae95db1c3ce4d07122e39dde2c9c5af02"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1const__mem__functor7"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1const__mem__functor7')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1const__mem__functor7.html">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td></tr>
+<tr class="memitem:a73af81d23d0fa816b8ef00acb1970d43 inherit pub_types_classsigc_1_1const__mem__functor7"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor7.html#a73af81d23d0fa816b8ef00acb1970d43">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const</td></tr>
+<tr class="separator:a73af81d23d0fa816b8ef00acb1970d43 inherit pub_types_classsigc_1_1const__mem__functor7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a724b8b210493e0d3cf06b5a393b91546 inherit pub_types_classsigc_1_1const__mem__functor7"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor7.html#a724b8b210493e0d3cf06b5a393b91546">result_type</a></td></tr>
+<tr class="separator:a724b8b210493e0d3cf06b5a393b91546 inherit pub_types_classsigc_1_1const__mem__functor7"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a22e365208dda5614599860d5794cb64f"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html#a22e365208dda5614599860d5794cb64f">bound_const_mem_functor7</a> (const T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__const__mem__functor7.html#ae95db1c3ce4d07122e39dde2c9c5af02">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a22e365208dda5614599860d5794cb64f"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor7.html" title="bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance.">bound_const_mem_functor7</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__mem__functor7.html#a22e365208dda5614599860d5794cb64f">More...</a><br /></td></tr>
+<tr class="separator:a22e365208dda5614599860d5794cb64f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3353dd997ced3fc00f44ee2b8ccb0063"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html#a3353dd997ced3fc00f44ee2b8ccb0063">bound_const_mem_functor7</a> (const T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__const__mem__functor7.html#ae95db1c3ce4d07122e39dde2c9c5af02">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a3353dd997ced3fc00f44ee2b8ccb0063"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor7.html" title="bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance.">bound_const_mem_functor7</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__mem__functor7.html#a3353dd997ced3fc00f44ee2b8ccb0063">More...</a><br /></td></tr>
+<tr class="separator:a3353dd997ced3fc00f44ee2b8ccb0063"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a941b925ad1f628cde49bb268be8daf4a"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html#a941b925ad1f628cde49bb268be8daf4a">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:a941b925ad1f628cde49bb268be8daf4a"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__const__mem__functor7.html#a941b925ad1f628cde49bb268be8daf4a">More...</a><br /></td></tr>
+<tr class="separator:a941b925ad1f628cde49bb268be8daf4a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1const__mem__functor7"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1const__mem__functor7')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1const__mem__functor7.html">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td></tr>
+<tr class="memitem:add4d7f74905c6bc20afc6f7681f367c0 inherit pub_methods_classsigc_1_1const__mem__functor7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor7.html#add4d7f74905c6bc20afc6f7681f367c0">const_mem_functor7</a> ()</td></tr>
+<tr class="memdesc:add4d7f74905c6bc20afc6f7681f367c0 inherit pub_methods_classsigc_1_1const__mem__functor7"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__mem__functor7.html#add4d7f74905c6bc20afc6f7681f367c0">More...</a><br /></td></tr>
+<tr class="separator:add4d7f74905c6bc20afc6f7681f367c0 inherit pub_methods_classsigc_1_1const__mem__functor7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0538bba01694fc13456fcee0e96d8f34 inherit pub_methods_classsigc_1_1const__mem__functor7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor7.html#a0538bba01694fc13456fcee0e96d8f34">const_mem_functor7</a> (<a class="el" href="classsigc_1_1const__mem__functor7.html#a73af81d23d0fa816b8ef00acb1970d43">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a0538bba01694fc13456fcee0e96d8f34 inherit pub_methods_classsigc_1_1const__mem__functor7"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__mem__functor7.html" title="const_mem_functor7 wraps const methods with 7 argument(s).">const_mem_functor7</a> object that wraps the passed method. <a href="classsigc_1_1const__mem__functor7.html#a0538bba01694fc13456fcee0e96d8f34">More...</a><br /></td></tr>
+<tr class="separator:a0538bba01694fc13456fcee0e96d8f34 inherit pub_methods_classsigc_1_1const__mem__functor7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab49dc9f302ef22e4b76043d9bc2f5062 inherit pub_methods_classsigc_1_1const__mem__functor7"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor7.html#ab49dc9f302ef22e4b76043d9bc2f5062">operator()</a> (const T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:ab49dc9f302ef22e4b76043d9bc2f5062 inherit pub_methods_classsigc_1_1const__mem__functor7"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor7.html#ab49dc9f302ef22e4b76043d9bc2f5062">More...</a><br /></td></tr>
+<tr class="separator:ab49dc9f302ef22e4b76043d9bc2f5062 inherit pub_methods_classsigc_1_1const__mem__functor7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a53f19248e5b61460759d7cdbf41ca21b inherit pub_methods_classsigc_1_1const__mem__functor7"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor7.html#a53f19248e5b61460759d7cdbf41ca21b">operator()</a> (const T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:a53f19248e5b61460759d7cdbf41ca21b inherit pub_methods_classsigc_1_1const__mem__functor7"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor7.html#a53f19248e5b61460759d7cdbf41ca21b">More...</a><br /></td></tr>
+<tr class="separator:a53f19248e5b61460759d7cdbf41ca21b inherit pub_methods_classsigc_1_1const__mem__functor7"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:a2b59ccc18d96b4b2ec0f6828a5c2a6e0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__limit__reference.html">const_limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html#a2b59ccc18d96b4b2ec0f6828a5c2a6e0">obj_</a></td></tr>
+<tr class="separator:a2b59ccc18d96b4b2ec0f6828a5c2a6e0"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1const__mem__functor7"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1const__mem__functor7')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1const__mem__functor7.html">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td></tr>
+<tr class="memitem:a255588607e165db8bd25c3bb8d7e1fbe inherit pro_attribs_classsigc_1_1const__mem__functor7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor7.html#a73af81d23d0fa816b8ef00acb1970d43">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor7.html#a255588607e165db8bd25c3bb8d7e1fbe">func_ptr_</a></td></tr>
+<tr class="separator:a255588607e165db8bd25c3bb8d7e1fbe inherit pro_attribs_classsigc_1_1const__mem__functor7"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7><br />
+class sigc::bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__const__mem__functor7.html" title="bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance.">bound_const_mem_functor7</a> encapsulates a const method with 7 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__const__mem__functor7.html" title="bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance.">bound_const_mem_functor7</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__mem__functor7.html#a941b925ad1f628cde49bb268be8daf4a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__mem__functor7.html#a941b925ad1f628cde49bb268be8daf4a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__mem__functor7.html#a941b925ad1f628cde49bb268be8daf4a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__mem__functor7.html#a941b925ad1f628cde49bb268be8daf4a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__mem__functor7.html#a941b925ad1f628cde49bb268be8daf4a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg6</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__mem__functor7.html#a941b925ad1f628cde49bb268be8daf4a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg7</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__mem__functor7.html#a941b925ad1f628cde49bb268be8daf4a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__const__mem__functor7.html#a941b925ad1f628cde49bb268be8daf4a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="ae95db1c3ce4d07122e39dde2c9c5af02"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae95db1c3ce4d07122e39dde2c9c5af02">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__const__mem__functor7.html">sigc::bound_const_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1bound__const__mem__functor7.html#ae95db1c3ce4d07122e39dde2c9c5af02">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a3353dd997ced3fc00f44ee2b8ccb0063"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3353dd997ced3fc00f44ee2b8ccb0063">◆ </a></span>bound_const_mem_functor7() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html">sigc::bound_const_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1bound__const__mem__functor7.html">bound_const_mem_functor7</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html#ae95db1c3ce4d07122e39dde2c9c5af02">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor7.html" title="bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance.">bound_const_mem_functor7</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000177">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__mem__functor7.html#a941b925ad1f628cde49bb268be8daf4a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a22e365208dda5614599860d5794cb64f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a22e365208dda5614599860d5794cb64f">◆ </a></span>bound_const_mem_functor7() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html">sigc::bound_const_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1bound__const__mem__functor7.html">bound_const_mem_functor7</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html#ae95db1c3ce4d07122e39dde2c9c5af02">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__mem__functor7.html" title="bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance.">bound_const_mem_functor7</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__mem__functor7.html#a941b925ad1f628cde49bb268be8daf4a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a941b925ad1f628cde49bb268be8daf4a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a941b925ad1f628cde49bb268be8daf4a">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__const__mem__functor7.html">sigc::bound_const_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > </td>
+ <td class="paramname"><em>_A_a7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a7</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a2b59ccc18d96b4b2ec0f6828a5c2a6e0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2b59ccc18d96b4b2ec0f6828a5c2a6e0">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__limit__reference.html">const_limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__const__mem__functor7.html">sigc::bound_const_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >" name="sigc::bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >">
+<area shape="rect" id="node1" title="bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance." alt="" coords="435,5,613,91"/>
+<area shape="rect" id="node2" href="$classsigc_1_1const__mem__functor7.html" title="const_mem_functor7 wraps const methods with 7 argument(s)." alt="" coords="193,13,387,83"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,35,145,61"/>
+</map>
--- /dev/null
+a6a6e77b84f1c4ad0da2e2009e8415fa
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">bound_const_volatile_mem_functor0</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_const_volatile_mem_functor0< T_return, T_obj > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">sigc::bound_const_volatile_mem_functor0< T_return, T_obj ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html#a364e1b19994e41acf1d99d27ffca8924">bound_const_volatile_mem_functor0</a>(const T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">sigc::bound_const_volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html#a12e99e7dc91602d1e7170a791f96a616">bound_const_volatile_mem_functor0</a>(const T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">sigc::bound_const_volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#a8eec4c4ff04b8d5ef7c184e853ea0486">const_volatile_mem_functor0</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">sigc::const_volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#ab20dd00a6c8908a8ebd7846985d71856">const_volatile_mem_functor0</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">sigc::const_volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#ae0f88c6683fb175845f5f804c2c04ec8">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">sigc::const_volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html#a622322ff2ef93f0e611fd6f93f6ccdcc">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">sigc::bound_const_volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html#adfea0aeaf66e1531da58af3051327949">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">sigc::bound_const_volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html#abbe8bbaa0d3d7318046be146fe6fda03">operator()</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">sigc::bound_const_volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#a86005d47b02e980c90d135a636e21674">sigc::const_volatile_mem_functor0::operator()</a>(const T_obj * _A_obj) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">sigc::const_volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#adfd64d64707c012329915edf19190772">sigc::const_volatile_mem_functor0::operator()</a>(const T_obj & _A_obj) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">sigc::const_volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#ab8e419ef5ad21d6230a306cd7d910df9">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">sigc::const_volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_const_volatile_mem_functor0< T_return, T_obj > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">bound_const_volatile_mem_functor0</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__const__volatile__mem__functor0-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_const_volatile_mem_functor0< T_return, T_obj > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html" title="bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object...">bound_const_volatile_mem_functor0</a> encapsulates a const volatile method with 0 arguments and an object instance.
+ <a href="classsigc_1_1bound__const__volatile__mem__functor0.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_const_volatile_mem_functor0< T_return, T_obj >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__const__volatile__mem__functor0__inherit__graph.png" border="0" usemap="#asigc_1_1bound__const__volatile__mem__functor0_3_01T__return_00_01T__obj_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__const__volatile__mem__functor0_3_01T__return_00_01T__obj_01_4_inherit__map" id="asigc_1_1bound__const__volatile__mem__functor0_3_01T__return_00_01T__obj_01_4_inherit__map">
+<area shape="rect" title="bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object..." alt="" coords="5,184,203,240"/>
+<area shape="rect" href="classsigc_1_1const__volatile__mem__functor0.html" title="const_volatile_mem_functor0 wraps const volatile methods with 0 argument(s)." alt="" coords="5,80,203,136"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a622322ff2ef93f0e611fd6f93f6ccdcc"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html#a622322ff2ef93f0e611fd6f93f6ccdcc">function_type</a></td></tr>
+<tr class="separator:a622322ff2ef93f0e611fd6f93f6ccdcc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1const__volatile__mem__functor0"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1const__volatile__mem__functor0')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">sigc::const_volatile_mem_functor0< T_return, T_obj ></a></td></tr>
+<tr class="memitem:a3247f7d0e3804ff455e0996b969f6c59 inherit pub_types_classsigc_1_1const__volatile__mem__functor0"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#a3247f7d0e3804ff455e0996b969f6c59">function_type</a>) () const volatile</td></tr>
+<tr class="separator:a3247f7d0e3804ff455e0996b969f6c59 inherit pub_types_classsigc_1_1const__volatile__mem__functor0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab8e419ef5ad21d6230a306cd7d910df9 inherit pub_types_classsigc_1_1const__volatile__mem__functor0"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#ab8e419ef5ad21d6230a306cd7d910df9">result_type</a></td></tr>
+<tr class="separator:ab8e419ef5ad21d6230a306cd7d910df9 inherit pub_types_classsigc_1_1const__volatile__mem__functor0"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a12e99e7dc91602d1e7170a791f96a616"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html#a12e99e7dc91602d1e7170a791f96a616">bound_const_volatile_mem_functor0</a> (const T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html#a622322ff2ef93f0e611fd6f93f6ccdcc">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a12e99e7dc91602d1e7170a791f96a616"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html" title="bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object...">bound_const_volatile_mem_functor0</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__volatile__mem__functor0.html#a12e99e7dc91602d1e7170a791f96a616">More...</a><br /></td></tr>
+<tr class="separator:a12e99e7dc91602d1e7170a791f96a616"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a364e1b19994e41acf1d99d27ffca8924"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html#a364e1b19994e41acf1d99d27ffca8924">bound_const_volatile_mem_functor0</a> (const T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html#a622322ff2ef93f0e611fd6f93f6ccdcc">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a364e1b19994e41acf1d99d27ffca8924"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html" title="bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object...">bound_const_volatile_mem_functor0</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__volatile__mem__functor0.html#a364e1b19994e41acf1d99d27ffca8924">More...</a><br /></td></tr>
+<tr class="separator:a364e1b19994e41acf1d99d27ffca8924"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abbe8bbaa0d3d7318046be146fe6fda03"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html#abbe8bbaa0d3d7318046be146fe6fda03">operator()</a> () const</td></tr>
+<tr class="memdesc:abbe8bbaa0d3d7318046be146fe6fda03"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__const__volatile__mem__functor0.html#abbe8bbaa0d3d7318046be146fe6fda03">More...</a><br /></td></tr>
+<tr class="separator:abbe8bbaa0d3d7318046be146fe6fda03"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1const__volatile__mem__functor0"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1const__volatile__mem__functor0')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">sigc::const_volatile_mem_functor0< T_return, T_obj ></a></td></tr>
+<tr class="memitem:a8eec4c4ff04b8d5ef7c184e853ea0486 inherit pub_methods_classsigc_1_1const__volatile__mem__functor0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#a8eec4c4ff04b8d5ef7c184e853ea0486">const_volatile_mem_functor0</a> ()</td></tr>
+<tr class="memdesc:a8eec4c4ff04b8d5ef7c184e853ea0486 inherit pub_methods_classsigc_1_1const__volatile__mem__functor0"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__volatile__mem__functor0.html#a8eec4c4ff04b8d5ef7c184e853ea0486">More...</a><br /></td></tr>
+<tr class="separator:a8eec4c4ff04b8d5ef7c184e853ea0486 inherit pub_methods_classsigc_1_1const__volatile__mem__functor0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab20dd00a6c8908a8ebd7846985d71856 inherit pub_methods_classsigc_1_1const__volatile__mem__functor0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#ab20dd00a6c8908a8ebd7846985d71856">const_volatile_mem_functor0</a> (<a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#a3247f7d0e3804ff455e0996b969f6c59">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:ab20dd00a6c8908a8ebd7846985d71856 inherit pub_methods_classsigc_1_1const__volatile__mem__functor0"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html" title="const_volatile_mem_functor0 wraps const volatile methods with 0 argument(s).">const_volatile_mem_functor0</a> object that wraps the passed method. <a href="classsigc_1_1const__volatile__mem__functor0.html#ab20dd00a6c8908a8ebd7846985d71856">More...</a><br /></td></tr>
+<tr class="separator:ab20dd00a6c8908a8ebd7846985d71856 inherit pub_methods_classsigc_1_1const__volatile__mem__functor0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adfd64d64707c012329915edf19190772 inherit pub_methods_classsigc_1_1const__volatile__mem__functor0"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#adfd64d64707c012329915edf19190772">operator()</a> (const T_obj & _A_obj) const</td></tr>
+<tr class="memdesc:adfd64d64707c012329915edf19190772 inherit pub_methods_classsigc_1_1const__volatile__mem__functor0"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor0.html#adfd64d64707c012329915edf19190772">More...</a><br /></td></tr>
+<tr class="separator:adfd64d64707c012329915edf19190772 inherit pub_methods_classsigc_1_1const__volatile__mem__functor0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a86005d47b02e980c90d135a636e21674 inherit pub_methods_classsigc_1_1const__volatile__mem__functor0"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#a86005d47b02e980c90d135a636e21674">operator()</a> (const T_obj * _A_obj) const</td></tr>
+<tr class="memdesc:a86005d47b02e980c90d135a636e21674 inherit pub_methods_classsigc_1_1const__volatile__mem__functor0"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor0.html#a86005d47b02e980c90d135a636e21674">More...</a><br /></td></tr>
+<tr class="separator:a86005d47b02e980c90d135a636e21674 inherit pub_methods_classsigc_1_1const__volatile__mem__functor0"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:adfea0aeaf66e1531da58af3051327949"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html">const_volatile_limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html#adfea0aeaf66e1531da58af3051327949">obj_</a></td></tr>
+<tr class="separator:adfea0aeaf66e1531da58af3051327949"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1const__volatile__mem__functor0"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1const__volatile__mem__functor0')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">sigc::const_volatile_mem_functor0< T_return, T_obj ></a></td></tr>
+<tr class="memitem:ae0f88c6683fb175845f5f804c2c04ec8 inherit pro_attribs_classsigc_1_1const__volatile__mem__functor0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#a3247f7d0e3804ff455e0996b969f6c59">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#ae0f88c6683fb175845f5f804c2c04ec8">func_ptr_</a></td></tr>
+<tr class="separator:ae0f88c6683fb175845f5f804c2c04ec8 inherit pro_attribs_classsigc_1_1const__volatile__mem__functor0"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj><br />
+class sigc::bound_const_volatile_mem_functor0< T_return, T_obj ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html" title="bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object...">bound_const_volatile_mem_functor0</a> encapsulates a const volatile method with 0 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html" title="bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object...">bound_const_volatile_mem_functor0</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html#abbe8bbaa0d3d7318046be146fe6fda03" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a622322ff2ef93f0e611fd6f93f6ccdcc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a622322ff2ef93f0e611fd6f93f6ccdcc">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">sigc::bound_const_volatile_mem_functor0</a>< T_return, T_obj >::<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html#a622322ff2ef93f0e611fd6f93f6ccdcc">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a364e1b19994e41acf1d99d27ffca8924"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a364e1b19994e41acf1d99d27ffca8924">◆ </a></span>bound_const_volatile_mem_functor0() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">sigc::bound_const_volatile_mem_functor0</a>< T_return, T_obj >::<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">bound_const_volatile_mem_functor0</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html#a622322ff2ef93f0e611fd6f93f6ccdcc">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html" title="bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object...">bound_const_volatile_mem_functor0</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000186">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html#abbe8bbaa0d3d7318046be146fe6fda03" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a12e99e7dc91602d1e7170a791f96a616"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a12e99e7dc91602d1e7170a791f96a616">◆ </a></span>bound_const_volatile_mem_functor0() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">sigc::bound_const_volatile_mem_functor0</a>< T_return, T_obj >::<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">bound_const_volatile_mem_functor0</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html#a622322ff2ef93f0e611fd6f93f6ccdcc">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html" title="bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object...">bound_const_volatile_mem_functor0</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html#abbe8bbaa0d3d7318046be146fe6fda03" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="abbe8bbaa0d3d7318046be146fe6fda03"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abbe8bbaa0d3d7318046be146fe6fda03">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">sigc::bound_const_volatile_mem_functor0</a>< T_return, T_obj >::operator() </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="adfea0aeaf66e1531da58af3051327949"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#adfea0aeaf66e1531da58af3051327949">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html">const_volatile_limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">sigc::bound_const_volatile_mem_functor0</a>< T_return, T_obj >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_const_volatile_mem_functor0< T_return, T_obj >" name="sigc::bound_const_volatile_mem_functor0< T_return, T_obj >">
+<area shape="rect" id="node1" title="bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object..." alt="" coords="5,184,203,240"/>
+<area shape="rect" id="node2" href="$classsigc_1_1const__volatile__mem__functor0.html" title="const_volatile_mem_functor0 wraps const volatile methods with 0 argument(s)." alt="" coords="5,80,203,136"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
--- /dev/null
+b0d1af7ce40b0fabc7816905ced9850e
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">bound_const_volatile_mem_functor1</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">sigc::bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html#ac99241e0e7ba52e295f6176c03cdd741">bound_const_volatile_mem_functor1</a>(const T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">sigc::bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html#aaccca7de16e3da31976680b714d10e79">bound_const_volatile_mem_functor1</a>(const T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">sigc::bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#a25a541c4bef874a6b2d177a3be7ab988">const_volatile_mem_functor1</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#aa8cb4ad934ac610ffe3425cbe799ba8d">const_volatile_mem_functor1</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#af9da27522999030f09c718dbe164f1f6">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html#ac7a0c09914219d8baf1715675e838e59">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">sigc::bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html#a4c6537ee7b64251b8f418047cb9fd87d">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">sigc::bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html#a0c520be9f25daa56ca9aba061edb7e77">operator()</a>(type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">sigc::bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#a9af06968e1db65f5bd136175e10d250f">sigc::const_volatile_mem_functor1::operator()</a>(const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#a715b1d5c56a537cbd397875e8eba532d">sigc::const_volatile_mem_functor1::operator()</a>(const T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#adeaf82cc2aff607efe2a51945d6b8565">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">bound_const_volatile_mem_functor1</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__const__volatile__mem__functor1-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html" title="bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object...">bound_const_volatile_mem_functor1</a> encapsulates a const volatile method with 1 arguments and an object instance.
+ <a href="classsigc_1_1bound__const__volatile__mem__functor1.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__const__volatile__mem__functor1__inherit__graph.png" border="0" usemap="#asigc_1_1bound__const__volatile__mem__functor1_3_01T__return_00_01T__obj_00_01T__arg1_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__const__volatile__mem__functor1_3_01T__return_00_01T__obj_00_01T__arg1_01_4_inherit__map" id="asigc_1_1bound__const__volatile__mem__functor1_3_01T__return_00_01T__obj_00_01T__arg1_01_4_inherit__map">
+<area shape="rect" title="bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object..." alt="" coords="5,184,203,240"/>
+<area shape="rect" href="classsigc_1_1const__volatile__mem__functor1.html" title="const_volatile_mem_functor1 wraps const volatile methods with 1 argument(s)." alt="" coords="5,80,203,136"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:ac7a0c09914219d8baf1715675e838e59"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html#ac7a0c09914219d8baf1715675e838e59">function_type</a></td></tr>
+<tr class="separator:ac7a0c09914219d8baf1715675e838e59"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1const__volatile__mem__functor1"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1const__volatile__mem__functor1')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td></tr>
+<tr class="memitem:acc367f8d6ee646c370623650a7ed6cde inherit pub_types_classsigc_1_1const__volatile__mem__functor1"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#acc367f8d6ee646c370623650a7ed6cde">function_type</a>) (T_arg1) const volatile</td></tr>
+<tr class="separator:acc367f8d6ee646c370623650a7ed6cde inherit pub_types_classsigc_1_1const__volatile__mem__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adeaf82cc2aff607efe2a51945d6b8565 inherit pub_types_classsigc_1_1const__volatile__mem__functor1"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#adeaf82cc2aff607efe2a51945d6b8565">result_type</a></td></tr>
+<tr class="separator:adeaf82cc2aff607efe2a51945d6b8565 inherit pub_types_classsigc_1_1const__volatile__mem__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:aaccca7de16e3da31976680b714d10e79"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html#aaccca7de16e3da31976680b714d10e79">bound_const_volatile_mem_functor1</a> (const T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html#ac7a0c09914219d8baf1715675e838e59">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:aaccca7de16e3da31976680b714d10e79"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html" title="bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object...">bound_const_volatile_mem_functor1</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__volatile__mem__functor1.html#aaccca7de16e3da31976680b714d10e79">More...</a><br /></td></tr>
+<tr class="separator:aaccca7de16e3da31976680b714d10e79"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac99241e0e7ba52e295f6176c03cdd741"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html#ac99241e0e7ba52e295f6176c03cdd741">bound_const_volatile_mem_functor1</a> (const T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html#ac7a0c09914219d8baf1715675e838e59">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:ac99241e0e7ba52e295f6176c03cdd741"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html" title="bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object...">bound_const_volatile_mem_functor1</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__volatile__mem__functor1.html#ac99241e0e7ba52e295f6176c03cdd741">More...</a><br /></td></tr>
+<tr class="separator:ac99241e0e7ba52e295f6176c03cdd741"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0c520be9f25daa56ca9aba061edb7e77"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html#a0c520be9f25daa56ca9aba061edb7e77">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a0c520be9f25daa56ca9aba061edb7e77"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__const__volatile__mem__functor1.html#a0c520be9f25daa56ca9aba061edb7e77">More...</a><br /></td></tr>
+<tr class="separator:a0c520be9f25daa56ca9aba061edb7e77"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1const__volatile__mem__functor1"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1const__volatile__mem__functor1')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td></tr>
+<tr class="memitem:a25a541c4bef874a6b2d177a3be7ab988 inherit pub_methods_classsigc_1_1const__volatile__mem__functor1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#a25a541c4bef874a6b2d177a3be7ab988">const_volatile_mem_functor1</a> ()</td></tr>
+<tr class="memdesc:a25a541c4bef874a6b2d177a3be7ab988 inherit pub_methods_classsigc_1_1const__volatile__mem__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__volatile__mem__functor1.html#a25a541c4bef874a6b2d177a3be7ab988">More...</a><br /></td></tr>
+<tr class="separator:a25a541c4bef874a6b2d177a3be7ab988 inherit pub_methods_classsigc_1_1const__volatile__mem__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa8cb4ad934ac610ffe3425cbe799ba8d inherit pub_methods_classsigc_1_1const__volatile__mem__functor1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#aa8cb4ad934ac610ffe3425cbe799ba8d">const_volatile_mem_functor1</a> (<a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#acc367f8d6ee646c370623650a7ed6cde">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:aa8cb4ad934ac610ffe3425cbe799ba8d inherit pub_methods_classsigc_1_1const__volatile__mem__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html" title="const_volatile_mem_functor1 wraps const volatile methods with 1 argument(s).">const_volatile_mem_functor1</a> object that wraps the passed method. <a href="classsigc_1_1const__volatile__mem__functor1.html#aa8cb4ad934ac610ffe3425cbe799ba8d">More...</a><br /></td></tr>
+<tr class="separator:aa8cb4ad934ac610ffe3425cbe799ba8d inherit pub_methods_classsigc_1_1const__volatile__mem__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a715b1d5c56a537cbd397875e8eba532d inherit pub_methods_classsigc_1_1const__volatile__mem__functor1"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#a715b1d5c56a537cbd397875e8eba532d">operator()</a> (const T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a715b1d5c56a537cbd397875e8eba532d inherit pub_methods_classsigc_1_1const__volatile__mem__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor1.html#a715b1d5c56a537cbd397875e8eba532d">More...</a><br /></td></tr>
+<tr class="separator:a715b1d5c56a537cbd397875e8eba532d inherit pub_methods_classsigc_1_1const__volatile__mem__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9af06968e1db65f5bd136175e10d250f inherit pub_methods_classsigc_1_1const__volatile__mem__functor1"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#a9af06968e1db65f5bd136175e10d250f">operator()</a> (const T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a9af06968e1db65f5bd136175e10d250f inherit pub_methods_classsigc_1_1const__volatile__mem__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor1.html#a9af06968e1db65f5bd136175e10d250f">More...</a><br /></td></tr>
+<tr class="separator:a9af06968e1db65f5bd136175e10d250f inherit pub_methods_classsigc_1_1const__volatile__mem__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:a4c6537ee7b64251b8f418047cb9fd87d"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html">const_volatile_limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html#a4c6537ee7b64251b8f418047cb9fd87d">obj_</a></td></tr>
+<tr class="separator:a4c6537ee7b64251b8f418047cb9fd87d"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1const__volatile__mem__functor1"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1const__volatile__mem__functor1')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td></tr>
+<tr class="memitem:af9da27522999030f09c718dbe164f1f6 inherit pro_attribs_classsigc_1_1const__volatile__mem__functor1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#acc367f8d6ee646c370623650a7ed6cde">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#af9da27522999030f09c718dbe164f1f6">func_ptr_</a></td></tr>
+<tr class="separator:af9da27522999030f09c718dbe164f1f6 inherit pro_attribs_classsigc_1_1const__volatile__mem__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1><br />
+class sigc::bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html" title="bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object...">bound_const_volatile_mem_functor1</a> encapsulates a const volatile method with 1 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html" title="bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object...">bound_const_volatile_mem_functor1</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html#a0c520be9f25daa56ca9aba061edb7e77" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html#a0c520be9f25daa56ca9aba061edb7e77" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="ac7a0c09914219d8baf1715675e838e59"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac7a0c09914219d8baf1715675e838e59">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">sigc::bound_const_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >::<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html#ac7a0c09914219d8baf1715675e838e59">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="ac99241e0e7ba52e295f6176c03cdd741"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac99241e0e7ba52e295f6176c03cdd741">◆ </a></span>bound_const_volatile_mem_functor1() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">sigc::bound_const_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >::<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">bound_const_volatile_mem_functor1</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html#ac7a0c09914219d8baf1715675e838e59">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html" title="bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object...">bound_const_volatile_mem_functor1</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000187">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html#a0c520be9f25daa56ca9aba061edb7e77" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="aaccca7de16e3da31976680b714d10e79"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aaccca7de16e3da31976680b714d10e79">◆ </a></span>bound_const_volatile_mem_functor1() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">sigc::bound_const_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >::<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">bound_const_volatile_mem_functor1</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html#ac7a0c09914219d8baf1715675e838e59">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html" title="bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object...">bound_const_volatile_mem_functor1</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html#a0c520be9f25daa56ca9aba061edb7e77" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a0c520be9f25daa56ca9aba061edb7e77"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0c520be9f25daa56ca9aba061edb7e77">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">sigc::bound_const_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a4c6537ee7b64251b8f418047cb9fd87d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4c6537ee7b64251b8f418047cb9fd87d">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html">const_volatile_limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">sigc::bound_const_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 >" name="sigc::bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 >">
+<area shape="rect" id="node1" title="bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object..." alt="" coords="5,184,203,240"/>
+<area shape="rect" id="node2" href="$classsigc_1_1const__volatile__mem__functor1.html" title="const_volatile_mem_functor1 wraps const volatile methods with 1 argument(s)." alt="" coords="5,80,203,136"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
--- /dev/null
+d89b1e345478861516a74fc38a2192e6
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">bound_const_volatile_mem_functor2</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">sigc::bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a1b629cd2ff30fcaeb035136e190c3f4d">bound_const_volatile_mem_functor2</a>(const T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">sigc::bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a6a7a540b5e6a5e7d322a448904bc8881">bound_const_volatile_mem_functor2</a>(const T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">sigc::bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#ad99060cf675fb65cbc00f2b8e9ec3068">const_volatile_mem_functor2</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#ada3da9a8dd692377c90abbfa9bcfe73a">const_volatile_mem_functor2</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#aac7f64e6cff784ecd6700d0448d8e796">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a26e4bc5d2c64c1029b760fe7994fee3f">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">sigc::bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a28eef54f97c2468f3385358b75d6cb70">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">sigc::bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a434acb850963a28b1a5a4662fad2b5d5">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">sigc::bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#a9d024cf10df876df77183e1fb79a52ec">sigc::const_volatile_mem_functor2::operator()</a>(const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#a467a45cf9bc54bed0f3c5bade3329067">sigc::const_volatile_mem_functor2::operator()</a>(const T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#a0d143bb32627f7a0c17270321df8145f">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">bound_const_volatile_mem_functor2</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__const__volatile__mem__functor2-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html" title="bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object...">bound_const_volatile_mem_functor2</a> encapsulates a const volatile method with 2 arguments and an object instance.
+ <a href="classsigc_1_1bound__const__volatile__mem__functor2.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__const__volatile__mem__functor2__inherit__graph.png" border="0" usemap="#asigc_1_1bound__const__volatile__mem__functor2_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__const__volatile__mem__functor2_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_01_4_inherit__map" id="asigc_1_1bound__const__volatile__mem__functor2_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_01_4_inherit__map">
+<area shape="rect" title="bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object..." alt="" coords="5,184,203,240"/>
+<area shape="rect" href="classsigc_1_1const__volatile__mem__functor2.html" title="const_volatile_mem_functor2 wraps const volatile methods with 2 argument(s)." alt="" coords="5,80,203,136"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a26e4bc5d2c64c1029b760fe7994fee3f"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a26e4bc5d2c64c1029b760fe7994fee3f">function_type</a></td></tr>
+<tr class="separator:a26e4bc5d2c64c1029b760fe7994fee3f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1const__volatile__mem__functor2"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1const__volatile__mem__functor2')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td></tr>
+<tr class="memitem:ac46d1e343e669092d6bb24aa8b5d5dbb inherit pub_types_classsigc_1_1const__volatile__mem__functor2"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#ac46d1e343e669092d6bb24aa8b5d5dbb">function_type</a>) (T_arg1, T_arg2) const volatile</td></tr>
+<tr class="separator:ac46d1e343e669092d6bb24aa8b5d5dbb inherit pub_types_classsigc_1_1const__volatile__mem__functor2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0d143bb32627f7a0c17270321df8145f inherit pub_types_classsigc_1_1const__volatile__mem__functor2"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#a0d143bb32627f7a0c17270321df8145f">result_type</a></td></tr>
+<tr class="separator:a0d143bb32627f7a0c17270321df8145f inherit pub_types_classsigc_1_1const__volatile__mem__functor2"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a6a7a540b5e6a5e7d322a448904bc8881"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a6a7a540b5e6a5e7d322a448904bc8881">bound_const_volatile_mem_functor2</a> (const T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a26e4bc5d2c64c1029b760fe7994fee3f">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a6a7a540b5e6a5e7d322a448904bc8881"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html" title="bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object...">bound_const_volatile_mem_functor2</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__volatile__mem__functor2.html#a6a7a540b5e6a5e7d322a448904bc8881">More...</a><br /></td></tr>
+<tr class="separator:a6a7a540b5e6a5e7d322a448904bc8881"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1b629cd2ff30fcaeb035136e190c3f4d"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a1b629cd2ff30fcaeb035136e190c3f4d">bound_const_volatile_mem_functor2</a> (const T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a26e4bc5d2c64c1029b760fe7994fee3f">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a1b629cd2ff30fcaeb035136e190c3f4d"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html" title="bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object...">bound_const_volatile_mem_functor2</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__volatile__mem__functor2.html#a1b629cd2ff30fcaeb035136e190c3f4d">More...</a><br /></td></tr>
+<tr class="separator:a1b629cd2ff30fcaeb035136e190c3f4d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a434acb850963a28b1a5a4662fad2b5d5"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a434acb850963a28b1a5a4662fad2b5d5">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:a434acb850963a28b1a5a4662fad2b5d5"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__const__volatile__mem__functor2.html#a434acb850963a28b1a5a4662fad2b5d5">More...</a><br /></td></tr>
+<tr class="separator:a434acb850963a28b1a5a4662fad2b5d5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1const__volatile__mem__functor2"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1const__volatile__mem__functor2')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td></tr>
+<tr class="memitem:ad99060cf675fb65cbc00f2b8e9ec3068 inherit pub_methods_classsigc_1_1const__volatile__mem__functor2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#ad99060cf675fb65cbc00f2b8e9ec3068">const_volatile_mem_functor2</a> ()</td></tr>
+<tr class="memdesc:ad99060cf675fb65cbc00f2b8e9ec3068 inherit pub_methods_classsigc_1_1const__volatile__mem__functor2"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__volatile__mem__functor2.html#ad99060cf675fb65cbc00f2b8e9ec3068">More...</a><br /></td></tr>
+<tr class="separator:ad99060cf675fb65cbc00f2b8e9ec3068 inherit pub_methods_classsigc_1_1const__volatile__mem__functor2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ada3da9a8dd692377c90abbfa9bcfe73a inherit pub_methods_classsigc_1_1const__volatile__mem__functor2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#ada3da9a8dd692377c90abbfa9bcfe73a">const_volatile_mem_functor2</a> (<a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#ac46d1e343e669092d6bb24aa8b5d5dbb">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:ada3da9a8dd692377c90abbfa9bcfe73a inherit pub_methods_classsigc_1_1const__volatile__mem__functor2"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html" title="const_volatile_mem_functor2 wraps const volatile methods with 2 argument(s).">const_volatile_mem_functor2</a> object that wraps the passed method. <a href="classsigc_1_1const__volatile__mem__functor2.html#ada3da9a8dd692377c90abbfa9bcfe73a">More...</a><br /></td></tr>
+<tr class="separator:ada3da9a8dd692377c90abbfa9bcfe73a inherit pub_methods_classsigc_1_1const__volatile__mem__functor2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a467a45cf9bc54bed0f3c5bade3329067 inherit pub_methods_classsigc_1_1const__volatile__mem__functor2"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#a467a45cf9bc54bed0f3c5bade3329067">operator()</a> (const T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:a467a45cf9bc54bed0f3c5bade3329067 inherit pub_methods_classsigc_1_1const__volatile__mem__functor2"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor2.html#a467a45cf9bc54bed0f3c5bade3329067">More...</a><br /></td></tr>
+<tr class="separator:a467a45cf9bc54bed0f3c5bade3329067 inherit pub_methods_classsigc_1_1const__volatile__mem__functor2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9d024cf10df876df77183e1fb79a52ec inherit pub_methods_classsigc_1_1const__volatile__mem__functor2"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#a9d024cf10df876df77183e1fb79a52ec">operator()</a> (const T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:a9d024cf10df876df77183e1fb79a52ec inherit pub_methods_classsigc_1_1const__volatile__mem__functor2"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor2.html#a9d024cf10df876df77183e1fb79a52ec">More...</a><br /></td></tr>
+<tr class="separator:a9d024cf10df876df77183e1fb79a52ec inherit pub_methods_classsigc_1_1const__volatile__mem__functor2"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:a28eef54f97c2468f3385358b75d6cb70"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html">const_volatile_limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a28eef54f97c2468f3385358b75d6cb70">obj_</a></td></tr>
+<tr class="separator:a28eef54f97c2468f3385358b75d6cb70"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1const__volatile__mem__functor2"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1const__volatile__mem__functor2')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td></tr>
+<tr class="memitem:aac7f64e6cff784ecd6700d0448d8e796 inherit pro_attribs_classsigc_1_1const__volatile__mem__functor2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#ac46d1e343e669092d6bb24aa8b5d5dbb">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#aac7f64e6cff784ecd6700d0448d8e796">func_ptr_</a></td></tr>
+<tr class="separator:aac7f64e6cff784ecd6700d0448d8e796 inherit pro_attribs_classsigc_1_1const__volatile__mem__functor2"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2><br />
+class sigc::bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html" title="bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object...">bound_const_volatile_mem_functor2</a> encapsulates a const volatile method with 2 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html" title="bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object...">bound_const_volatile_mem_functor2</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a434acb850963a28b1a5a4662fad2b5d5" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a434acb850963a28b1a5a4662fad2b5d5" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a434acb850963a28b1a5a4662fad2b5d5" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a26e4bc5d2c64c1029b760fe7994fee3f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a26e4bc5d2c64c1029b760fe7994fee3f">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">sigc::bound_const_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a26e4bc5d2c64c1029b760fe7994fee3f">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a1b629cd2ff30fcaeb035136e190c3f4d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1b629cd2ff30fcaeb035136e190c3f4d">◆ </a></span>bound_const_volatile_mem_functor2() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">sigc::bound_const_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">bound_const_volatile_mem_functor2</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a26e4bc5d2c64c1029b760fe7994fee3f">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html" title="bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object...">bound_const_volatile_mem_functor2</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000188">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a434acb850963a28b1a5a4662fad2b5d5" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a6a7a540b5e6a5e7d322a448904bc8881"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a6a7a540b5e6a5e7d322a448904bc8881">◆ </a></span>bound_const_volatile_mem_functor2() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">sigc::bound_const_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">bound_const_volatile_mem_functor2</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a26e4bc5d2c64c1029b760fe7994fee3f">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html" title="bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object...">bound_const_volatile_mem_functor2</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a434acb850963a28b1a5a4662fad2b5d5" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a434acb850963a28b1a5a4662fad2b5d5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a434acb850963a28b1a5a4662fad2b5d5">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">sigc::bound_const_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a28eef54f97c2468f3385358b75d6cb70"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a28eef54f97c2468f3385358b75d6cb70">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html">const_volatile_limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">sigc::bound_const_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >" name="sigc::bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >">
+<area shape="rect" id="node1" title="bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object..." alt="" coords="5,184,203,240"/>
+<area shape="rect" id="node2" href="$classsigc_1_1const__volatile__mem__functor2.html" title="const_volatile_mem_functor2 wraps const volatile methods with 2 argument(s)." alt="" coords="5,80,203,136"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
--- /dev/null
+bcf8e32d86133ec90e9690b999f87601
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">bound_const_volatile_mem_functor3</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">sigc::bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#a7c5661cbb3554624e50c62789f339aaf">bound_const_volatile_mem_functor3</a>(const T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">sigc::bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#a3fbbc6533b408ccde3d517b1f2a38223">bound_const_volatile_mem_functor3</a>(const T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">sigc::bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#af284f300a6b3696f6379dcc9ed97a744">const_volatile_mem_functor3</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#aa586f24064b6a5c8b69c963fff614d04">const_volatile_mem_functor3</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a6ffedac451ab4f525bd7c9df0b83cf2c">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#ae127200c20b69f91ccaf40eb60f2c448">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">sigc::bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#a65b0c3f640389160aa73a299aed8c512">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">sigc::bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#af14d93c72657777d2257e3db60f20a01">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">sigc::bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a47374a80a3a61b69e39478ca9a4a4776">sigc::const_volatile_mem_functor3::operator()</a>(const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a4af918f707067763bb2031d8758991d5">sigc::const_volatile_mem_functor3::operator()</a>(const T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#ad2056f73eed4664ff41f5e673a2276f0">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">bound_const_volatile_mem_functor3</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__const__volatile__mem__functor3-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html" title="bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object...">bound_const_volatile_mem_functor3</a> encapsulates a const volatile method with 3 arguments and an object instance.
+ <a href="classsigc_1_1bound__const__volatile__mem__functor3.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__const__volatile__mem__functor3__inherit__graph.png" border="0" usemap="#asigc_1_1bound__const__volatile__mem__functor3_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__const__volatile__mem__functor3_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_01_4_inherit__map" id="asigc_1_1bound__const__volatile__mem__functor3_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_01_4_inherit__map">
+<area shape="rect" title="bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object..." alt="" coords="5,199,237,255"/>
+<area shape="rect" href="classsigc_1_1const__volatile__mem__functor3.html" title="const_volatile_mem_functor3 wraps const volatile methods with 3 argument(s)." alt="" coords="23,80,220,151"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="51,5,191,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:ae127200c20b69f91ccaf40eb60f2c448"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#ae127200c20b69f91ccaf40eb60f2c448">function_type</a></td></tr>
+<tr class="separator:ae127200c20b69f91ccaf40eb60f2c448"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1const__volatile__mem__functor3"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1const__volatile__mem__functor3')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td></tr>
+<tr class="memitem:a472ab7835e2b6792a108f4fcc80d4669 inherit pub_types_classsigc_1_1const__volatile__mem__functor3"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a472ab7835e2b6792a108f4fcc80d4669">function_type</a>) (T_arg1, T_arg2, T_arg3) const volatile</td></tr>
+<tr class="separator:a472ab7835e2b6792a108f4fcc80d4669 inherit pub_types_classsigc_1_1const__volatile__mem__functor3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad2056f73eed4664ff41f5e673a2276f0 inherit pub_types_classsigc_1_1const__volatile__mem__functor3"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#ad2056f73eed4664ff41f5e673a2276f0">result_type</a></td></tr>
+<tr class="separator:ad2056f73eed4664ff41f5e673a2276f0 inherit pub_types_classsigc_1_1const__volatile__mem__functor3"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a3fbbc6533b408ccde3d517b1f2a38223"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#a3fbbc6533b408ccde3d517b1f2a38223">bound_const_volatile_mem_functor3</a> (const T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#ae127200c20b69f91ccaf40eb60f2c448">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a3fbbc6533b408ccde3d517b1f2a38223"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html" title="bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object...">bound_const_volatile_mem_functor3</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__volatile__mem__functor3.html#a3fbbc6533b408ccde3d517b1f2a38223">More...</a><br /></td></tr>
+<tr class="separator:a3fbbc6533b408ccde3d517b1f2a38223"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7c5661cbb3554624e50c62789f339aaf"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#a7c5661cbb3554624e50c62789f339aaf">bound_const_volatile_mem_functor3</a> (const T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#ae127200c20b69f91ccaf40eb60f2c448">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a7c5661cbb3554624e50c62789f339aaf"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html" title="bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object...">bound_const_volatile_mem_functor3</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__volatile__mem__functor3.html#a7c5661cbb3554624e50c62789f339aaf">More...</a><br /></td></tr>
+<tr class="separator:a7c5661cbb3554624e50c62789f339aaf"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af14d93c72657777d2257e3db60f20a01"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#af14d93c72657777d2257e3db60f20a01">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:af14d93c72657777d2257e3db60f20a01"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__const__volatile__mem__functor3.html#af14d93c72657777d2257e3db60f20a01">More...</a><br /></td></tr>
+<tr class="separator:af14d93c72657777d2257e3db60f20a01"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1const__volatile__mem__functor3"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1const__volatile__mem__functor3')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td></tr>
+<tr class="memitem:af284f300a6b3696f6379dcc9ed97a744 inherit pub_methods_classsigc_1_1const__volatile__mem__functor3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#af284f300a6b3696f6379dcc9ed97a744">const_volatile_mem_functor3</a> ()</td></tr>
+<tr class="memdesc:af284f300a6b3696f6379dcc9ed97a744 inherit pub_methods_classsigc_1_1const__volatile__mem__functor3"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__volatile__mem__functor3.html#af284f300a6b3696f6379dcc9ed97a744">More...</a><br /></td></tr>
+<tr class="separator:af284f300a6b3696f6379dcc9ed97a744 inherit pub_methods_classsigc_1_1const__volatile__mem__functor3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa586f24064b6a5c8b69c963fff614d04 inherit pub_methods_classsigc_1_1const__volatile__mem__functor3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#aa586f24064b6a5c8b69c963fff614d04">const_volatile_mem_functor3</a> (<a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a472ab7835e2b6792a108f4fcc80d4669">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:aa586f24064b6a5c8b69c963fff614d04 inherit pub_methods_classsigc_1_1const__volatile__mem__functor3"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html" title="const_volatile_mem_functor3 wraps const volatile methods with 3 argument(s).">const_volatile_mem_functor3</a> object that wraps the passed method. <a href="classsigc_1_1const__volatile__mem__functor3.html#aa586f24064b6a5c8b69c963fff614d04">More...</a><br /></td></tr>
+<tr class="separator:aa586f24064b6a5c8b69c963fff614d04 inherit pub_methods_classsigc_1_1const__volatile__mem__functor3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4af918f707067763bb2031d8758991d5 inherit pub_methods_classsigc_1_1const__volatile__mem__functor3"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a4af918f707067763bb2031d8758991d5">operator()</a> (const T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:a4af918f707067763bb2031d8758991d5 inherit pub_methods_classsigc_1_1const__volatile__mem__functor3"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor3.html#a4af918f707067763bb2031d8758991d5">More...</a><br /></td></tr>
+<tr class="separator:a4af918f707067763bb2031d8758991d5 inherit pub_methods_classsigc_1_1const__volatile__mem__functor3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a47374a80a3a61b69e39478ca9a4a4776 inherit pub_methods_classsigc_1_1const__volatile__mem__functor3"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a47374a80a3a61b69e39478ca9a4a4776">operator()</a> (const T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:a47374a80a3a61b69e39478ca9a4a4776 inherit pub_methods_classsigc_1_1const__volatile__mem__functor3"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor3.html#a47374a80a3a61b69e39478ca9a4a4776">More...</a><br /></td></tr>
+<tr class="separator:a47374a80a3a61b69e39478ca9a4a4776 inherit pub_methods_classsigc_1_1const__volatile__mem__functor3"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:a65b0c3f640389160aa73a299aed8c512"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html">const_volatile_limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#a65b0c3f640389160aa73a299aed8c512">obj_</a></td></tr>
+<tr class="separator:a65b0c3f640389160aa73a299aed8c512"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1const__volatile__mem__functor3"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1const__volatile__mem__functor3')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td></tr>
+<tr class="memitem:a6ffedac451ab4f525bd7c9df0b83cf2c inherit pro_attribs_classsigc_1_1const__volatile__mem__functor3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a472ab7835e2b6792a108f4fcc80d4669">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a6ffedac451ab4f525bd7c9df0b83cf2c">func_ptr_</a></td></tr>
+<tr class="separator:a6ffedac451ab4f525bd7c9df0b83cf2c inherit pro_attribs_classsigc_1_1const__volatile__mem__functor3"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3><br />
+class sigc::bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html" title="bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object...">bound_const_volatile_mem_functor3</a> encapsulates a const volatile method with 3 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html" title="bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object...">bound_const_volatile_mem_functor3</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#af14d93c72657777d2257e3db60f20a01" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#af14d93c72657777d2257e3db60f20a01" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#af14d93c72657777d2257e3db60f20a01" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#af14d93c72657777d2257e3db60f20a01" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="ae127200c20b69f91ccaf40eb60f2c448"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae127200c20b69f91ccaf40eb60f2c448">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">sigc::bound_const_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#ae127200c20b69f91ccaf40eb60f2c448">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a7c5661cbb3554624e50c62789f339aaf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7c5661cbb3554624e50c62789f339aaf">◆ </a></span>bound_const_volatile_mem_functor3() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">sigc::bound_const_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">bound_const_volatile_mem_functor3</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#ae127200c20b69f91ccaf40eb60f2c448">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html" title="bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object...">bound_const_volatile_mem_functor3</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000189">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#af14d93c72657777d2257e3db60f20a01" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a3fbbc6533b408ccde3d517b1f2a38223"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3fbbc6533b408ccde3d517b1f2a38223">◆ </a></span>bound_const_volatile_mem_functor3() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">sigc::bound_const_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">bound_const_volatile_mem_functor3</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#ae127200c20b69f91ccaf40eb60f2c448">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html" title="bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object...">bound_const_volatile_mem_functor3</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#af14d93c72657777d2257e3db60f20a01" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="af14d93c72657777d2257e3db60f20a01"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af14d93c72657777d2257e3db60f20a01">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">sigc::bound_const_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a65b0c3f640389160aa73a299aed8c512"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a65b0c3f640389160aa73a299aed8c512">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html">const_volatile_limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">sigc::bound_const_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >" name="sigc::bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >">
+<area shape="rect" id="node1" title="bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object..." alt="" coords="5,199,237,255"/>
+<area shape="rect" id="node2" href="$classsigc_1_1const__volatile__mem__functor3.html" title="const_volatile_mem_functor3 wraps const volatile methods with 3 argument(s)." alt="" coords="23,80,220,151"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="51,5,191,32"/>
+</map>
--- /dev/null
+920501a74fd51233f6bf0454057153f3
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">bound_const_volatile_mem_functor4</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">sigc::bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#a97b15b931ba6db1852011d252dd3d5f0">bound_const_volatile_mem_functor4</a>(const T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">sigc::bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#a4e0fdda617113a58f8839ab53a9fa613">bound_const_volatile_mem_functor4</a>(const T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">sigc::bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#aad7b7f5037a0c8d13668f9c350e010ee">const_volatile_mem_functor4</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a0ffe59d6392c736e6d14c43a4bfa26e5">const_volatile_mem_functor4</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a0714aabc799c5d41af988650fec71410">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#a2c06c731ae9564be215802a98541d06c">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">sigc::bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#a52abd6d1eb7dd0919ecb6d3a667b0e18">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">sigc::bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#ac1593becd15c2704535c9b50482503f9">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">sigc::bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a589c68eddffeb3399838d2af7f5b6d19">sigc::const_volatile_mem_functor4::operator()</a>(const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a7cd0900e7e3c8523503e037e7c696f5d">sigc::const_volatile_mem_functor4::operator()</a>(const T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a8e38a0816627c7ad4fd48278d287f863">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">bound_const_volatile_mem_functor4</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__const__volatile__mem__functor4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html" title="bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object...">bound_const_volatile_mem_functor4</a> encapsulates a const volatile method with 4 arguments and an object instance.
+ <a href="classsigc_1_1bound__const__volatile__mem__functor4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__const__volatile__mem__functor4__inherit__graph.png" border="0" usemap="#asigc_1_1bound__const__volatile__mem__functor4_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__const__volatile__mem__functor4_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_01_4_inherit__map" id="asigc_1_1bound__const__volatile__mem__functor4_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_01_4_inherit__map">
+<area shape="rect" title="bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object..." alt="" coords="439,5,636,76"/>
+<area shape="rect" href="classsigc_1_1const__volatile__mem__functor4.html" title="const_volatile_mem_functor4 wraps const volatile methods with 4 argument(s)." alt="" coords="193,5,391,76"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,27,145,54"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a2c06c731ae9564be215802a98541d06c"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#a2c06c731ae9564be215802a98541d06c">function_type</a></td></tr>
+<tr class="separator:a2c06c731ae9564be215802a98541d06c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1const__volatile__mem__functor4"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1const__volatile__mem__functor4')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td></tr>
+<tr class="memitem:ace3cb54e6265ebe06ee2995dd01f2540 inherit pub_types_classsigc_1_1const__volatile__mem__functor4"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#ace3cb54e6265ebe06ee2995dd01f2540">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4) const volatile</td></tr>
+<tr class="separator:ace3cb54e6265ebe06ee2995dd01f2540 inherit pub_types_classsigc_1_1const__volatile__mem__functor4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8e38a0816627c7ad4fd48278d287f863 inherit pub_types_classsigc_1_1const__volatile__mem__functor4"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a8e38a0816627c7ad4fd48278d287f863">result_type</a></td></tr>
+<tr class="separator:a8e38a0816627c7ad4fd48278d287f863 inherit pub_types_classsigc_1_1const__volatile__mem__functor4"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a4e0fdda617113a58f8839ab53a9fa613"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#a4e0fdda617113a58f8839ab53a9fa613">bound_const_volatile_mem_functor4</a> (const T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#a2c06c731ae9564be215802a98541d06c">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a4e0fdda617113a58f8839ab53a9fa613"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html" title="bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object...">bound_const_volatile_mem_functor4</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__volatile__mem__functor4.html#a4e0fdda617113a58f8839ab53a9fa613">More...</a><br /></td></tr>
+<tr class="separator:a4e0fdda617113a58f8839ab53a9fa613"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a97b15b931ba6db1852011d252dd3d5f0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#a97b15b931ba6db1852011d252dd3d5f0">bound_const_volatile_mem_functor4</a> (const T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#a2c06c731ae9564be215802a98541d06c">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a97b15b931ba6db1852011d252dd3d5f0"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html" title="bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object...">bound_const_volatile_mem_functor4</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__volatile__mem__functor4.html#a97b15b931ba6db1852011d252dd3d5f0">More...</a><br /></td></tr>
+<tr class="separator:a97b15b931ba6db1852011d252dd3d5f0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac1593becd15c2704535c9b50482503f9"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#ac1593becd15c2704535c9b50482503f9">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:ac1593becd15c2704535c9b50482503f9"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__const__volatile__mem__functor4.html#ac1593becd15c2704535c9b50482503f9">More...</a><br /></td></tr>
+<tr class="separator:ac1593becd15c2704535c9b50482503f9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1const__volatile__mem__functor4"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1const__volatile__mem__functor4')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td></tr>
+<tr class="memitem:aad7b7f5037a0c8d13668f9c350e010ee inherit pub_methods_classsigc_1_1const__volatile__mem__functor4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#aad7b7f5037a0c8d13668f9c350e010ee">const_volatile_mem_functor4</a> ()</td></tr>
+<tr class="memdesc:aad7b7f5037a0c8d13668f9c350e010ee inherit pub_methods_classsigc_1_1const__volatile__mem__functor4"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__volatile__mem__functor4.html#aad7b7f5037a0c8d13668f9c350e010ee">More...</a><br /></td></tr>
+<tr class="separator:aad7b7f5037a0c8d13668f9c350e010ee inherit pub_methods_classsigc_1_1const__volatile__mem__functor4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0ffe59d6392c736e6d14c43a4bfa26e5 inherit pub_methods_classsigc_1_1const__volatile__mem__functor4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a0ffe59d6392c736e6d14c43a4bfa26e5">const_volatile_mem_functor4</a> (<a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#ace3cb54e6265ebe06ee2995dd01f2540">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a0ffe59d6392c736e6d14c43a4bfa26e5 inherit pub_methods_classsigc_1_1const__volatile__mem__functor4"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html" title="const_volatile_mem_functor4 wraps const volatile methods with 4 argument(s).">const_volatile_mem_functor4</a> object that wraps the passed method. <a href="classsigc_1_1const__volatile__mem__functor4.html#a0ffe59d6392c736e6d14c43a4bfa26e5">More...</a><br /></td></tr>
+<tr class="separator:a0ffe59d6392c736e6d14c43a4bfa26e5 inherit pub_methods_classsigc_1_1const__volatile__mem__functor4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7cd0900e7e3c8523503e037e7c696f5d inherit pub_methods_classsigc_1_1const__volatile__mem__functor4"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a7cd0900e7e3c8523503e037e7c696f5d">operator()</a> (const T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:a7cd0900e7e3c8523503e037e7c696f5d inherit pub_methods_classsigc_1_1const__volatile__mem__functor4"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor4.html#a7cd0900e7e3c8523503e037e7c696f5d">More...</a><br /></td></tr>
+<tr class="separator:a7cd0900e7e3c8523503e037e7c696f5d inherit pub_methods_classsigc_1_1const__volatile__mem__functor4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a589c68eddffeb3399838d2af7f5b6d19 inherit pub_methods_classsigc_1_1const__volatile__mem__functor4"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a589c68eddffeb3399838d2af7f5b6d19">operator()</a> (const T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:a589c68eddffeb3399838d2af7f5b6d19 inherit pub_methods_classsigc_1_1const__volatile__mem__functor4"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor4.html#a589c68eddffeb3399838d2af7f5b6d19">More...</a><br /></td></tr>
+<tr class="separator:a589c68eddffeb3399838d2af7f5b6d19 inherit pub_methods_classsigc_1_1const__volatile__mem__functor4"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:a52abd6d1eb7dd0919ecb6d3a667b0e18"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html">const_volatile_limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#a52abd6d1eb7dd0919ecb6d3a667b0e18">obj_</a></td></tr>
+<tr class="separator:a52abd6d1eb7dd0919ecb6d3a667b0e18"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1const__volatile__mem__functor4"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1const__volatile__mem__functor4')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td></tr>
+<tr class="memitem:a0714aabc799c5d41af988650fec71410 inherit pro_attribs_classsigc_1_1const__volatile__mem__functor4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#ace3cb54e6265ebe06ee2995dd01f2540">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a0714aabc799c5d41af988650fec71410">func_ptr_</a></td></tr>
+<tr class="separator:a0714aabc799c5d41af988650fec71410 inherit pro_attribs_classsigc_1_1const__volatile__mem__functor4"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4><br />
+class sigc::bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html" title="bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object...">bound_const_volatile_mem_functor4</a> encapsulates a const volatile method with 4 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html" title="bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object...">bound_const_volatile_mem_functor4</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#ac1593becd15c2704535c9b50482503f9" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#ac1593becd15c2704535c9b50482503f9" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#ac1593becd15c2704535c9b50482503f9" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#ac1593becd15c2704535c9b50482503f9" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#ac1593becd15c2704535c9b50482503f9" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a2c06c731ae9564be215802a98541d06c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2c06c731ae9564be215802a98541d06c">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">sigc::bound_const_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#a2c06c731ae9564be215802a98541d06c">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a97b15b931ba6db1852011d252dd3d5f0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a97b15b931ba6db1852011d252dd3d5f0">◆ </a></span>bound_const_volatile_mem_functor4() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">sigc::bound_const_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">bound_const_volatile_mem_functor4</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#a2c06c731ae9564be215802a98541d06c">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html" title="bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object...">bound_const_volatile_mem_functor4</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000190">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#ac1593becd15c2704535c9b50482503f9" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a4e0fdda617113a58f8839ab53a9fa613"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4e0fdda617113a58f8839ab53a9fa613">◆ </a></span>bound_const_volatile_mem_functor4() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">sigc::bound_const_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">bound_const_volatile_mem_functor4</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#a2c06c731ae9564be215802a98541d06c">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html" title="bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object...">bound_const_volatile_mem_functor4</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#ac1593becd15c2704535c9b50482503f9" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="ac1593becd15c2704535c9b50482503f9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac1593becd15c2704535c9b50482503f9">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">sigc::bound_const_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a52abd6d1eb7dd0919ecb6d3a667b0e18"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a52abd6d1eb7dd0919ecb6d3a667b0e18">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html">const_volatile_limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">sigc::bound_const_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >" name="sigc::bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >">
+<area shape="rect" id="node1" title="bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object..." alt="" coords="439,5,636,76"/>
+<area shape="rect" id="node2" href="$classsigc_1_1const__volatile__mem__functor4.html" title="const_volatile_mem_functor4 wraps const volatile methods with 4 argument(s)." alt="" coords="193,5,391,76"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,27,145,54"/>
+</map>
--- /dev/null
+53a4542d0ccd9170d0078892b57e4e25
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">bound_const_volatile_mem_functor5</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">sigc::bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#acc05a40bf47bd943c5d822b354a80ae9">bound_const_volatile_mem_functor5</a>(const T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">sigc::bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#a178805b13affaa2b0fbaafe287cb9390">bound_const_volatile_mem_functor5</a>(const T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">sigc::bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#afe48307086c70740f39f58488a3cbdb5">const_volatile_mem_functor5</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a13787a099e237b44280ddbe9b8d97a04">const_volatile_mem_functor5</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a785d079f14f42cafd052639a1ebdaeb9">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#a54debcbe3edf1a9606aad9cfcc1e004c">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">sigc::bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#a72dab40d6161daa1ad1655a03e5a5aa4">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">sigc::bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#a7f70def3a438e6735b67f669c8fc107a">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">sigc::bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a7b1fde7647e7e936b29c97797835ca7b">sigc::const_volatile_mem_functor5::operator()</a>(const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a8d74b334440d1c9add3a358cd1913b11">sigc::const_volatile_mem_functor5::operator()</a>(const T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a42d6cd140b98358c1d12c90b975ad2b1">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">bound_const_volatile_mem_functor5</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__const__volatile__mem__functor5-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html" title="bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object...">bound_const_volatile_mem_functor5</a> encapsulates a const volatile method with 5 arguments and an object instance.
+ <a href="classsigc_1_1bound__const__volatile__mem__functor5.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__const__volatile__mem__functor5__inherit__graph.png" border="0" usemap="#asigc_1_1bound__const__volatile__mem__functor5_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__const__volatile__mem__functor5_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_01_4_inherit__map" id="asigc_1_1bound__const__volatile__mem__functor5_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_01_4_inherit__map">
+<area shape="rect" title="bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object..." alt="" coords="439,5,636,76"/>
+<area shape="rect" href="classsigc_1_1const__volatile__mem__functor5.html" title="const_volatile_mem_functor5 wraps const volatile methods with 5 argument(s)." alt="" coords="193,5,391,76"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,27,145,54"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a54debcbe3edf1a9606aad9cfcc1e004c"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#a54debcbe3edf1a9606aad9cfcc1e004c">function_type</a></td></tr>
+<tr class="separator:a54debcbe3edf1a9606aad9cfcc1e004c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1const__volatile__mem__functor5"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1const__volatile__mem__functor5')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td></tr>
+<tr class="memitem:a1d49a5a7086d41d1db2e40aed1273631 inherit pub_types_classsigc_1_1const__volatile__mem__functor5"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a1d49a5a7086d41d1db2e40aed1273631">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile</td></tr>
+<tr class="separator:a1d49a5a7086d41d1db2e40aed1273631 inherit pub_types_classsigc_1_1const__volatile__mem__functor5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a42d6cd140b98358c1d12c90b975ad2b1 inherit pub_types_classsigc_1_1const__volatile__mem__functor5"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a42d6cd140b98358c1d12c90b975ad2b1">result_type</a></td></tr>
+<tr class="separator:a42d6cd140b98358c1d12c90b975ad2b1 inherit pub_types_classsigc_1_1const__volatile__mem__functor5"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a178805b13affaa2b0fbaafe287cb9390"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#a178805b13affaa2b0fbaafe287cb9390">bound_const_volatile_mem_functor5</a> (const T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#a54debcbe3edf1a9606aad9cfcc1e004c">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a178805b13affaa2b0fbaafe287cb9390"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html" title="bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object...">bound_const_volatile_mem_functor5</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__volatile__mem__functor5.html#a178805b13affaa2b0fbaafe287cb9390">More...</a><br /></td></tr>
+<tr class="separator:a178805b13affaa2b0fbaafe287cb9390"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acc05a40bf47bd943c5d822b354a80ae9"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#acc05a40bf47bd943c5d822b354a80ae9">bound_const_volatile_mem_functor5</a> (const T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#a54debcbe3edf1a9606aad9cfcc1e004c">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:acc05a40bf47bd943c5d822b354a80ae9"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html" title="bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object...">bound_const_volatile_mem_functor5</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__volatile__mem__functor5.html#acc05a40bf47bd943c5d822b354a80ae9">More...</a><br /></td></tr>
+<tr class="separator:acc05a40bf47bd943c5d822b354a80ae9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7f70def3a438e6735b67f669c8fc107a"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#a7f70def3a438e6735b67f669c8fc107a">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:a7f70def3a438e6735b67f669c8fc107a"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__const__volatile__mem__functor5.html#a7f70def3a438e6735b67f669c8fc107a">More...</a><br /></td></tr>
+<tr class="separator:a7f70def3a438e6735b67f669c8fc107a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1const__volatile__mem__functor5"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1const__volatile__mem__functor5')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td></tr>
+<tr class="memitem:afe48307086c70740f39f58488a3cbdb5 inherit pub_methods_classsigc_1_1const__volatile__mem__functor5"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#afe48307086c70740f39f58488a3cbdb5">const_volatile_mem_functor5</a> ()</td></tr>
+<tr class="memdesc:afe48307086c70740f39f58488a3cbdb5 inherit pub_methods_classsigc_1_1const__volatile__mem__functor5"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__volatile__mem__functor5.html#afe48307086c70740f39f58488a3cbdb5">More...</a><br /></td></tr>
+<tr class="separator:afe48307086c70740f39f58488a3cbdb5 inherit pub_methods_classsigc_1_1const__volatile__mem__functor5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a13787a099e237b44280ddbe9b8d97a04 inherit pub_methods_classsigc_1_1const__volatile__mem__functor5"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a13787a099e237b44280ddbe9b8d97a04">const_volatile_mem_functor5</a> (<a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a1d49a5a7086d41d1db2e40aed1273631">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a13787a099e237b44280ddbe9b8d97a04 inherit pub_methods_classsigc_1_1const__volatile__mem__functor5"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html" title="const_volatile_mem_functor5 wraps const volatile methods with 5 argument(s).">const_volatile_mem_functor5</a> object that wraps the passed method. <a href="classsigc_1_1const__volatile__mem__functor5.html#a13787a099e237b44280ddbe9b8d97a04">More...</a><br /></td></tr>
+<tr class="separator:a13787a099e237b44280ddbe9b8d97a04 inherit pub_methods_classsigc_1_1const__volatile__mem__functor5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8d74b334440d1c9add3a358cd1913b11 inherit pub_methods_classsigc_1_1const__volatile__mem__functor5"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a8d74b334440d1c9add3a358cd1913b11">operator()</a> (const T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:a8d74b334440d1c9add3a358cd1913b11 inherit pub_methods_classsigc_1_1const__volatile__mem__functor5"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor5.html#a8d74b334440d1c9add3a358cd1913b11">More...</a><br /></td></tr>
+<tr class="separator:a8d74b334440d1c9add3a358cd1913b11 inherit pub_methods_classsigc_1_1const__volatile__mem__functor5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7b1fde7647e7e936b29c97797835ca7b inherit pub_methods_classsigc_1_1const__volatile__mem__functor5"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a7b1fde7647e7e936b29c97797835ca7b">operator()</a> (const T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:a7b1fde7647e7e936b29c97797835ca7b inherit pub_methods_classsigc_1_1const__volatile__mem__functor5"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor5.html#a7b1fde7647e7e936b29c97797835ca7b">More...</a><br /></td></tr>
+<tr class="separator:a7b1fde7647e7e936b29c97797835ca7b inherit pub_methods_classsigc_1_1const__volatile__mem__functor5"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:a72dab40d6161daa1ad1655a03e5a5aa4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html">const_volatile_limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#a72dab40d6161daa1ad1655a03e5a5aa4">obj_</a></td></tr>
+<tr class="separator:a72dab40d6161daa1ad1655a03e5a5aa4"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1const__volatile__mem__functor5"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1const__volatile__mem__functor5')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td></tr>
+<tr class="memitem:a785d079f14f42cafd052639a1ebdaeb9 inherit pro_attribs_classsigc_1_1const__volatile__mem__functor5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a1d49a5a7086d41d1db2e40aed1273631">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a785d079f14f42cafd052639a1ebdaeb9">func_ptr_</a></td></tr>
+<tr class="separator:a785d079f14f42cafd052639a1ebdaeb9 inherit pro_attribs_classsigc_1_1const__volatile__mem__functor5"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5><br />
+class sigc::bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html" title="bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object...">bound_const_volatile_mem_functor5</a> encapsulates a const volatile method with 5 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html" title="bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object...">bound_const_volatile_mem_functor5</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#a7f70def3a438e6735b67f669c8fc107a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#a7f70def3a438e6735b67f669c8fc107a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#a7f70def3a438e6735b67f669c8fc107a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#a7f70def3a438e6735b67f669c8fc107a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#a7f70def3a438e6735b67f669c8fc107a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#a7f70def3a438e6735b67f669c8fc107a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a54debcbe3edf1a9606aad9cfcc1e004c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a54debcbe3edf1a9606aad9cfcc1e004c">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">sigc::bound_const_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#a54debcbe3edf1a9606aad9cfcc1e004c">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="acc05a40bf47bd943c5d822b354a80ae9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#acc05a40bf47bd943c5d822b354a80ae9">◆ </a></span>bound_const_volatile_mem_functor5() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">sigc::bound_const_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">bound_const_volatile_mem_functor5</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#a54debcbe3edf1a9606aad9cfcc1e004c">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html" title="bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object...">bound_const_volatile_mem_functor5</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000191">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#a7f70def3a438e6735b67f669c8fc107a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a178805b13affaa2b0fbaafe287cb9390"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a178805b13affaa2b0fbaafe287cb9390">◆ </a></span>bound_const_volatile_mem_functor5() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">sigc::bound_const_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">bound_const_volatile_mem_functor5</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#a54debcbe3edf1a9606aad9cfcc1e004c">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html" title="bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object...">bound_const_volatile_mem_functor5</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#a7f70def3a438e6735b67f669c8fc107a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a7f70def3a438e6735b67f669c8fc107a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7f70def3a438e6735b67f669c8fc107a">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">sigc::bound_const_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a72dab40d6161daa1ad1655a03e5a5aa4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a72dab40d6161daa1ad1655a03e5a5aa4">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html">const_volatile_limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">sigc::bound_const_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >" name="sigc::bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >">
+<area shape="rect" id="node1" title="bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object..." alt="" coords="439,5,636,76"/>
+<area shape="rect" id="node2" href="$classsigc_1_1const__volatile__mem__functor5.html" title="const_volatile_mem_functor5 wraps const volatile methods with 5 argument(s)." alt="" coords="193,5,391,76"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,27,145,54"/>
+</map>
--- /dev/null
+a775850f91225543ef5d13a0907b7ea7
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">bound_const_volatile_mem_functor6</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">sigc::bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#ae07e825b1d3ee4fa7d4dd45eb7f2fbad">bound_const_volatile_mem_functor6</a>(const T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">sigc::bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#ac5aa6dc8967fed463dd69f412ded1fd1">bound_const_volatile_mem_functor6</a>(const T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">sigc::bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#aa921f2d1cea8ddd987cdaa8df6479fab">const_volatile_mem_functor6</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#a09704c72e9b0353b04776522edefd57e">const_volatile_mem_functor6</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#aed412f2606f91f9c11567c37ae6175bc">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#aa8d75053aa097f0632c13bf1185f84a9">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">sigc::bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#abbd560d8331fbab5cd8a08afd756c8fc">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">sigc::bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#a9cd3a5dd70008fe70d17712cfee0f470">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">sigc::bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#adff33012b1d7a20cb39c41c19b1db9a5">sigc::const_volatile_mem_functor6::operator()</a>(const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#a5cf522fd8072a8f77e56cae87d65892f">sigc::const_volatile_mem_functor6::operator()</a>(const T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#a9f866db08b59a0960875f7608a0c93f0">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">bound_const_volatile_mem_functor6</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__const__volatile__mem__functor6-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html" title="bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object...">bound_const_volatile_mem_functor6</a> encapsulates a const volatile method with 6 arguments and an object instance.
+ <a href="classsigc_1_1bound__const__volatile__mem__functor6.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__const__volatile__mem__functor6__inherit__graph.png" border="0" usemap="#asigc_1_1bound__const__volatile__mem__functor6_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__const__volatile__mem__functor6_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_01_4_inherit__map" id="asigc_1_1bound__const__volatile__mem__functor6_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_01_4_inherit__map">
+<area shape="rect" title="bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object..." alt="" coords="439,13,668,83"/>
+<area shape="rect" href="classsigc_1_1const__volatile__mem__functor6.html" title="const_volatile_mem_functor6 wraps const volatile methods with 6 argument(s)." alt="" coords="193,5,391,91"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,35,145,61"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:aa8d75053aa097f0632c13bf1185f84a9"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#aa8d75053aa097f0632c13bf1185f84a9">function_type</a></td></tr>
+<tr class="separator:aa8d75053aa097f0632c13bf1185f84a9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1const__volatile__mem__functor6"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1const__volatile__mem__functor6')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td></tr>
+<tr class="memitem:af8da04ac5f6e2252f963f4f4bb87c9fd inherit pub_types_classsigc_1_1const__volatile__mem__functor6"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#af8da04ac5f6e2252f963f4f4bb87c9fd">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile</td></tr>
+<tr class="separator:af8da04ac5f6e2252f963f4f4bb87c9fd inherit pub_types_classsigc_1_1const__volatile__mem__functor6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f866db08b59a0960875f7608a0c93f0 inherit pub_types_classsigc_1_1const__volatile__mem__functor6"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#a9f866db08b59a0960875f7608a0c93f0">result_type</a></td></tr>
+<tr class="separator:a9f866db08b59a0960875f7608a0c93f0 inherit pub_types_classsigc_1_1const__volatile__mem__functor6"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:ac5aa6dc8967fed463dd69f412ded1fd1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#ac5aa6dc8967fed463dd69f412ded1fd1">bound_const_volatile_mem_functor6</a> (const T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#aa8d75053aa097f0632c13bf1185f84a9">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:ac5aa6dc8967fed463dd69f412ded1fd1"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html" title="bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object...">bound_const_volatile_mem_functor6</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__volatile__mem__functor6.html#ac5aa6dc8967fed463dd69f412ded1fd1">More...</a><br /></td></tr>
+<tr class="separator:ac5aa6dc8967fed463dd69f412ded1fd1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae07e825b1d3ee4fa7d4dd45eb7f2fbad"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#ae07e825b1d3ee4fa7d4dd45eb7f2fbad">bound_const_volatile_mem_functor6</a> (const T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#aa8d75053aa097f0632c13bf1185f84a9">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:ae07e825b1d3ee4fa7d4dd45eb7f2fbad"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html" title="bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object...">bound_const_volatile_mem_functor6</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__volatile__mem__functor6.html#ae07e825b1d3ee4fa7d4dd45eb7f2fbad">More...</a><br /></td></tr>
+<tr class="separator:ae07e825b1d3ee4fa7d4dd45eb7f2fbad"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9cd3a5dd70008fe70d17712cfee0f470"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#a9cd3a5dd70008fe70d17712cfee0f470">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:a9cd3a5dd70008fe70d17712cfee0f470"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__const__volatile__mem__functor6.html#a9cd3a5dd70008fe70d17712cfee0f470">More...</a><br /></td></tr>
+<tr class="separator:a9cd3a5dd70008fe70d17712cfee0f470"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1const__volatile__mem__functor6"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1const__volatile__mem__functor6')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td></tr>
+<tr class="memitem:aa921f2d1cea8ddd987cdaa8df6479fab inherit pub_methods_classsigc_1_1const__volatile__mem__functor6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#aa921f2d1cea8ddd987cdaa8df6479fab">const_volatile_mem_functor6</a> ()</td></tr>
+<tr class="memdesc:aa921f2d1cea8ddd987cdaa8df6479fab inherit pub_methods_classsigc_1_1const__volatile__mem__functor6"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__volatile__mem__functor6.html#aa921f2d1cea8ddd987cdaa8df6479fab">More...</a><br /></td></tr>
+<tr class="separator:aa921f2d1cea8ddd987cdaa8df6479fab inherit pub_methods_classsigc_1_1const__volatile__mem__functor6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a09704c72e9b0353b04776522edefd57e inherit pub_methods_classsigc_1_1const__volatile__mem__functor6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#a09704c72e9b0353b04776522edefd57e">const_volatile_mem_functor6</a> (<a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#af8da04ac5f6e2252f963f4f4bb87c9fd">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a09704c72e9b0353b04776522edefd57e inherit pub_methods_classsigc_1_1const__volatile__mem__functor6"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html" title="const_volatile_mem_functor6 wraps const volatile methods with 6 argument(s).">const_volatile_mem_functor6</a> object that wraps the passed method. <a href="classsigc_1_1const__volatile__mem__functor6.html#a09704c72e9b0353b04776522edefd57e">More...</a><br /></td></tr>
+<tr class="separator:a09704c72e9b0353b04776522edefd57e inherit pub_methods_classsigc_1_1const__volatile__mem__functor6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5cf522fd8072a8f77e56cae87d65892f inherit pub_methods_classsigc_1_1const__volatile__mem__functor6"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#a5cf522fd8072a8f77e56cae87d65892f">operator()</a> (const T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:a5cf522fd8072a8f77e56cae87d65892f inherit pub_methods_classsigc_1_1const__volatile__mem__functor6"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor6.html#a5cf522fd8072a8f77e56cae87d65892f">More...</a><br /></td></tr>
+<tr class="separator:a5cf522fd8072a8f77e56cae87d65892f inherit pub_methods_classsigc_1_1const__volatile__mem__functor6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adff33012b1d7a20cb39c41c19b1db9a5 inherit pub_methods_classsigc_1_1const__volatile__mem__functor6"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#adff33012b1d7a20cb39c41c19b1db9a5">operator()</a> (const T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:adff33012b1d7a20cb39c41c19b1db9a5 inherit pub_methods_classsigc_1_1const__volatile__mem__functor6"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor6.html#adff33012b1d7a20cb39c41c19b1db9a5">More...</a><br /></td></tr>
+<tr class="separator:adff33012b1d7a20cb39c41c19b1db9a5 inherit pub_methods_classsigc_1_1const__volatile__mem__functor6"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:abbd560d8331fbab5cd8a08afd756c8fc"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html">const_volatile_limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#abbd560d8331fbab5cd8a08afd756c8fc">obj_</a></td></tr>
+<tr class="separator:abbd560d8331fbab5cd8a08afd756c8fc"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1const__volatile__mem__functor6"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1const__volatile__mem__functor6')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td></tr>
+<tr class="memitem:aed412f2606f91f9c11567c37ae6175bc inherit pro_attribs_classsigc_1_1const__volatile__mem__functor6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#af8da04ac5f6e2252f963f4f4bb87c9fd">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#aed412f2606f91f9c11567c37ae6175bc">func_ptr_</a></td></tr>
+<tr class="separator:aed412f2606f91f9c11567c37ae6175bc inherit pro_attribs_classsigc_1_1const__volatile__mem__functor6"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6><br />
+class sigc::bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html" title="bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object...">bound_const_volatile_mem_functor6</a> encapsulates a const volatile method with 6 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html" title="bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object...">bound_const_volatile_mem_functor6</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#a9cd3a5dd70008fe70d17712cfee0f470" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#a9cd3a5dd70008fe70d17712cfee0f470" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#a9cd3a5dd70008fe70d17712cfee0f470" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#a9cd3a5dd70008fe70d17712cfee0f470" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#a9cd3a5dd70008fe70d17712cfee0f470" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg6</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#a9cd3a5dd70008fe70d17712cfee0f470" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#a9cd3a5dd70008fe70d17712cfee0f470" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="aa8d75053aa097f0632c13bf1185f84a9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa8d75053aa097f0632c13bf1185f84a9">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">sigc::bound_const_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#aa8d75053aa097f0632c13bf1185f84a9">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="ae07e825b1d3ee4fa7d4dd45eb7f2fbad"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae07e825b1d3ee4fa7d4dd45eb7f2fbad">◆ </a></span>bound_const_volatile_mem_functor6() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">sigc::bound_const_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">bound_const_volatile_mem_functor6</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#aa8d75053aa097f0632c13bf1185f84a9">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html" title="bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object...">bound_const_volatile_mem_functor6</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000192">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#a9cd3a5dd70008fe70d17712cfee0f470" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="ac5aa6dc8967fed463dd69f412ded1fd1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac5aa6dc8967fed463dd69f412ded1fd1">◆ </a></span>bound_const_volatile_mem_functor6() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">sigc::bound_const_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">bound_const_volatile_mem_functor6</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#aa8d75053aa097f0632c13bf1185f84a9">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html" title="bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object...">bound_const_volatile_mem_functor6</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#a9cd3a5dd70008fe70d17712cfee0f470" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a9cd3a5dd70008fe70d17712cfee0f470"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9cd3a5dd70008fe70d17712cfee0f470">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">sigc::bound_const_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="abbd560d8331fbab5cd8a08afd756c8fc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abbd560d8331fbab5cd8a08afd756c8fc">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html">const_volatile_limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">sigc::bound_const_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >" name="sigc::bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >">
+<area shape="rect" id="node1" title="bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object..." alt="" coords="439,13,668,83"/>
+<area shape="rect" id="node2" href="$classsigc_1_1const__volatile__mem__functor6.html" title="const_volatile_mem_functor6 wraps const volatile methods with 6 argument(s)." alt="" coords="193,5,391,91"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,35,145,61"/>
+</map>
--- /dev/null
+8c69e0bb2802632f2b8e3c6f78106ebb
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">bound_const_volatile_mem_functor7</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">sigc::bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#a6f2635a9548c06f2f5090d75df09fbf1">bound_const_volatile_mem_functor7</a>(const T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">sigc::bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#aed3adf188de8b282a4a597fb5e4a07bc">bound_const_volatile_mem_functor7</a>(const T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">sigc::bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#ac71290a7277b022f8a8d7abc4158a7ae">const_volatile_mem_functor7</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a95dcac66fbdb4c3b92682a1ddaa0309c">const_volatile_mem_functor7</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a3f19b8bff74776f040492d3410c54fa1">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#a48030a47276e3eede338fc78c79e5a35">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">sigc::bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#aec37eae62ba95f04b55dd6c55c6161c1">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">sigc::bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#a8fe1055d39082226d8acb3201b7b5ce7">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">sigc::bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a1c9477eed5eef826a4666817aee9ea25">sigc::const_volatile_mem_functor7::operator()</a>(const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a9cb200c4d7a95edf269ede2b9c7ab060">sigc::const_volatile_mem_functor7::operator()</a>(const T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a25cb7e6ed71406c5b91ab2696ad8e623">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">bound_const_volatile_mem_functor7</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__const__volatile__mem__functor7-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html" title="bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object...">bound_const_volatile_mem_functor7</a> encapsulates a const volatile method with 7 arguments and an object instance.
+ <a href="classsigc_1_1bound__const__volatile__mem__functor7.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__const__volatile__mem__functor7__inherit__graph.png" border="0" usemap="#asigc_1_1bound__const__volatile__mem__functor7_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__const__volatile__mem__functor7_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map" id="asigc_1_1bound__const__volatile__mem__functor7_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map">
+<area shape="rect" title="bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object..." alt="" coords="439,5,657,91"/>
+<area shape="rect" href="classsigc_1_1const__volatile__mem__functor7.html" title="const_volatile_mem_functor7 wraps const volatile methods with 7 argument(s)." alt="" coords="193,5,391,91"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,35,145,61"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a48030a47276e3eede338fc78c79e5a35"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#a48030a47276e3eede338fc78c79e5a35">function_type</a></td></tr>
+<tr class="separator:a48030a47276e3eede338fc78c79e5a35"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1const__volatile__mem__functor7"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1const__volatile__mem__functor7')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td></tr>
+<tr class="memitem:a7e3bac9b817c848b96e9d1b257be1de5 inherit pub_types_classsigc_1_1const__volatile__mem__functor7"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a7e3bac9b817c848b96e9d1b257be1de5">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile</td></tr>
+<tr class="separator:a7e3bac9b817c848b96e9d1b257be1de5 inherit pub_types_classsigc_1_1const__volatile__mem__functor7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a25cb7e6ed71406c5b91ab2696ad8e623 inherit pub_types_classsigc_1_1const__volatile__mem__functor7"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a25cb7e6ed71406c5b91ab2696ad8e623">result_type</a></td></tr>
+<tr class="separator:a25cb7e6ed71406c5b91ab2696ad8e623 inherit pub_types_classsigc_1_1const__volatile__mem__functor7"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:aed3adf188de8b282a4a597fb5e4a07bc"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#aed3adf188de8b282a4a597fb5e4a07bc">bound_const_volatile_mem_functor7</a> (const T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#a48030a47276e3eede338fc78c79e5a35">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:aed3adf188de8b282a4a597fb5e4a07bc"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html" title="bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object...">bound_const_volatile_mem_functor7</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__volatile__mem__functor7.html#aed3adf188de8b282a4a597fb5e4a07bc">More...</a><br /></td></tr>
+<tr class="separator:aed3adf188de8b282a4a597fb5e4a07bc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a6f2635a9548c06f2f5090d75df09fbf1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#a6f2635a9548c06f2f5090d75df09fbf1">bound_const_volatile_mem_functor7</a> (const T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#a48030a47276e3eede338fc78c79e5a35">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a6f2635a9548c06f2f5090d75df09fbf1"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html" title="bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object...">bound_const_volatile_mem_functor7</a> object that wraps the passed method. <a href="classsigc_1_1bound__const__volatile__mem__functor7.html#a6f2635a9548c06f2f5090d75df09fbf1">More...</a><br /></td></tr>
+<tr class="separator:a6f2635a9548c06f2f5090d75df09fbf1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8fe1055d39082226d8acb3201b7b5ce7"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#a8fe1055d39082226d8acb3201b7b5ce7">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:a8fe1055d39082226d8acb3201b7b5ce7"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__const__volatile__mem__functor7.html#a8fe1055d39082226d8acb3201b7b5ce7">More...</a><br /></td></tr>
+<tr class="separator:a8fe1055d39082226d8acb3201b7b5ce7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1const__volatile__mem__functor7"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1const__volatile__mem__functor7')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td></tr>
+<tr class="memitem:ac71290a7277b022f8a8d7abc4158a7ae inherit pub_methods_classsigc_1_1const__volatile__mem__functor7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#ac71290a7277b022f8a8d7abc4158a7ae">const_volatile_mem_functor7</a> ()</td></tr>
+<tr class="memdesc:ac71290a7277b022f8a8d7abc4158a7ae inherit pub_methods_classsigc_1_1const__volatile__mem__functor7"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__volatile__mem__functor7.html#ac71290a7277b022f8a8d7abc4158a7ae">More...</a><br /></td></tr>
+<tr class="separator:ac71290a7277b022f8a8d7abc4158a7ae inherit pub_methods_classsigc_1_1const__volatile__mem__functor7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a95dcac66fbdb4c3b92682a1ddaa0309c inherit pub_methods_classsigc_1_1const__volatile__mem__functor7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a95dcac66fbdb4c3b92682a1ddaa0309c">const_volatile_mem_functor7</a> (<a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a7e3bac9b817c848b96e9d1b257be1de5">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a95dcac66fbdb4c3b92682a1ddaa0309c inherit pub_methods_classsigc_1_1const__volatile__mem__functor7"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html" title="const_volatile_mem_functor7 wraps const volatile methods with 7 argument(s).">const_volatile_mem_functor7</a> object that wraps the passed method. <a href="classsigc_1_1const__volatile__mem__functor7.html#a95dcac66fbdb4c3b92682a1ddaa0309c">More...</a><br /></td></tr>
+<tr class="separator:a95dcac66fbdb4c3b92682a1ddaa0309c inherit pub_methods_classsigc_1_1const__volatile__mem__functor7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9cb200c4d7a95edf269ede2b9c7ab060 inherit pub_methods_classsigc_1_1const__volatile__mem__functor7"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a9cb200c4d7a95edf269ede2b9c7ab060">operator()</a> (const T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:a9cb200c4d7a95edf269ede2b9c7ab060 inherit pub_methods_classsigc_1_1const__volatile__mem__functor7"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor7.html#a9cb200c4d7a95edf269ede2b9c7ab060">More...</a><br /></td></tr>
+<tr class="separator:a9cb200c4d7a95edf269ede2b9c7ab060 inherit pub_methods_classsigc_1_1const__volatile__mem__functor7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1c9477eed5eef826a4666817aee9ea25 inherit pub_methods_classsigc_1_1const__volatile__mem__functor7"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a1c9477eed5eef826a4666817aee9ea25">operator()</a> (const T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:a1c9477eed5eef826a4666817aee9ea25 inherit pub_methods_classsigc_1_1const__volatile__mem__functor7"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor7.html#a1c9477eed5eef826a4666817aee9ea25">More...</a><br /></td></tr>
+<tr class="separator:a1c9477eed5eef826a4666817aee9ea25 inherit pub_methods_classsigc_1_1const__volatile__mem__functor7"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:aec37eae62ba95f04b55dd6c55c6161c1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html">const_volatile_limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#aec37eae62ba95f04b55dd6c55c6161c1">obj_</a></td></tr>
+<tr class="separator:aec37eae62ba95f04b55dd6c55c6161c1"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1const__volatile__mem__functor7"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1const__volatile__mem__functor7')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td></tr>
+<tr class="memitem:a3f19b8bff74776f040492d3410c54fa1 inherit pro_attribs_classsigc_1_1const__volatile__mem__functor7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a7e3bac9b817c848b96e9d1b257be1de5">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a3f19b8bff74776f040492d3410c54fa1">func_ptr_</a></td></tr>
+<tr class="separator:a3f19b8bff74776f040492d3410c54fa1 inherit pro_attribs_classsigc_1_1const__volatile__mem__functor7"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7><br />
+class sigc::bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html" title="bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object...">bound_const_volatile_mem_functor7</a> encapsulates a const volatile method with 7 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html" title="bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object...">bound_const_volatile_mem_functor7</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#a8fe1055d39082226d8acb3201b7b5ce7" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#a8fe1055d39082226d8acb3201b7b5ce7" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#a8fe1055d39082226d8acb3201b7b5ce7" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#a8fe1055d39082226d8acb3201b7b5ce7" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#a8fe1055d39082226d8acb3201b7b5ce7" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg6</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#a8fe1055d39082226d8acb3201b7b5ce7" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg7</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#a8fe1055d39082226d8acb3201b7b5ce7" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#a8fe1055d39082226d8acb3201b7b5ce7" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a48030a47276e3eede338fc78c79e5a35"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a48030a47276e3eede338fc78c79e5a35">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">sigc::bound_const_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#a48030a47276e3eede338fc78c79e5a35">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a6f2635a9548c06f2f5090d75df09fbf1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a6f2635a9548c06f2f5090d75df09fbf1">◆ </a></span>bound_const_volatile_mem_functor7() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">sigc::bound_const_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">bound_const_volatile_mem_functor7</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#a48030a47276e3eede338fc78c79e5a35">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html" title="bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object...">bound_const_volatile_mem_functor7</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000193">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#a8fe1055d39082226d8acb3201b7b5ce7" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="aed3adf188de8b282a4a597fb5e4a07bc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aed3adf188de8b282a4a597fb5e4a07bc">◆ </a></span>bound_const_volatile_mem_functor7() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">sigc::bound_const_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">bound_const_volatile_mem_functor7</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#a48030a47276e3eede338fc78c79e5a35">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html" title="bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object...">bound_const_volatile_mem_functor7</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#a8fe1055d39082226d8acb3201b7b5ce7" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a8fe1055d39082226d8acb3201b7b5ce7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8fe1055d39082226d8acb3201b7b5ce7">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">sigc::bound_const_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > </td>
+ <td class="paramname"><em>_A_a7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a7</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="aec37eae62ba95f04b55dd6c55c6161c1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aec37eae62ba95f04b55dd6c55c6161c1">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html">const_volatile_limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">sigc::bound_const_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >" name="sigc::bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >">
+<area shape="rect" id="node1" title="bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object..." alt="" coords="439,5,657,91"/>
+<area shape="rect" id="node2" href="$classsigc_1_1const__volatile__mem__functor7.html" title="const_volatile_mem_functor7 wraps const volatile methods with 7 argument(s)." alt="" coords="193,5,391,91"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,35,145,61"/>
+</map>
--- /dev/null
+3fe127ed46c98617d80f1760a1978688
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__mem__functor0.html">bound_mem_functor0</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_mem_functor0< T_return, T_obj > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__mem__functor0.html">sigc::bound_mem_functor0< T_return, T_obj ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor0.html#a7de90a27f55055cae43df1425cc78415">bound_mem_functor0</a>(T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor0.html">sigc::bound_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor0.html#a137ab7d3b66b421f664e154e3d01e66c">bound_mem_functor0</a>(T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor0.html">sigc::bound_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor0.html#a1f7b51d412900f55e155ecdd848fa283">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1mem__functor0.html">sigc::mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor0.html#a36b5479bfc091c063d44b11ad024393a">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor0.html">sigc::bound_mem_functor0< T_return, T_obj ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor0.html#ad598cd301fc54f3aa4da2b9e3c16bc81">mem_functor0</a>()</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor0.html">sigc::mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor0.html#a5655f48c6f36716dc15daf584f20d51c">mem_functor0</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor0.html">sigc::mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor0.html#ae64f4c6596667228376947a38c4a8bb7">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor0.html">sigc::bound_mem_functor0< T_return, T_obj ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor0.html#a8f0ea7caa1c5858b44ebdb0bcf4ba74a">operator()</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor0.html">sigc::bound_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor0.html#a0a8b70a8f59ddbdc3f1a9892c634bf48">sigc::mem_functor0::operator()</a>(T_obj * _A_obj) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor0.html">sigc::mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor0.html#a51d5213c9d41b51e3b8cca705bd801cc">sigc::mem_functor0::operator()</a>(T_obj & _A_obj) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor0.html">sigc::mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor0.html#aa679f73c7b786540686c110628a71dde">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor0.html">sigc::mem_functor0< T_return, T_obj ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_mem_functor0< T_return, T_obj > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__mem__functor0.html">bound_mem_functor0</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__mem__functor0-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_mem_functor0< T_return, T_obj > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__mem__functor0.html" title="bound_mem_functor0 encapsulates a method with 0 arguments and an object instance.">bound_mem_functor0</a> encapsulates a method with 0 arguments and an object instance.
+ <a href="classsigc_1_1bound__mem__functor0.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_mem_functor0< T_return, T_obj >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__mem__functor0__inherit__graph.png" border="0" usemap="#asigc_1_1bound__mem__functor0_3_01T__return_00_01T__obj_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__mem__functor0_3_01T__return_00_01T__obj_01_4_inherit__map" id="asigc_1_1bound__mem__functor0_3_01T__return_00_01T__obj_01_4_inherit__map">
+<area shape="rect" title="bound_mem_functor0 encapsulates a method with 0 arguments and an object instance." alt="" coords="5,169,204,211"/>
+<area shape="rect" href="classsigc_1_1mem__functor0.html" title="mem_functor0 wraps methods with 0 argument(s)." alt="" coords="29,80,180,121"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="35,5,175,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a36b5479bfc091c063d44b11ad024393a"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor0.html#a36b5479bfc091c063d44b11ad024393a">function_type</a></td></tr>
+<tr class="separator:a36b5479bfc091c063d44b11ad024393a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1mem__functor0"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1mem__functor0')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1mem__functor0.html">sigc::mem_functor0< T_return, T_obj ></a></td></tr>
+<tr class="memitem:a2b54ee0f1d0b0ca4f25707c85a5d4bab inherit pub_types_classsigc_1_1mem__functor0"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor0.html#a2b54ee0f1d0b0ca4f25707c85a5d4bab">function_type</a>) ()</td></tr>
+<tr class="separator:a2b54ee0f1d0b0ca4f25707c85a5d4bab inherit pub_types_classsigc_1_1mem__functor0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa679f73c7b786540686c110628a71dde inherit pub_types_classsigc_1_1mem__functor0"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor0.html#aa679f73c7b786540686c110628a71dde">result_type</a></td></tr>
+<tr class="separator:aa679f73c7b786540686c110628a71dde inherit pub_types_classsigc_1_1mem__functor0"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a137ab7d3b66b421f664e154e3d01e66c"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor0.html#a137ab7d3b66b421f664e154e3d01e66c">bound_mem_functor0</a> (T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__mem__functor0.html#a36b5479bfc091c063d44b11ad024393a">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a137ab7d3b66b421f664e154e3d01e66c"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__mem__functor0.html" title="bound_mem_functor0 encapsulates a method with 0 arguments and an object instance.">bound_mem_functor0</a> object that wraps the passed method. <a href="classsigc_1_1bound__mem__functor0.html#a137ab7d3b66b421f664e154e3d01e66c">More...</a><br /></td></tr>
+<tr class="separator:a137ab7d3b66b421f664e154e3d01e66c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7de90a27f55055cae43df1425cc78415"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor0.html#a7de90a27f55055cae43df1425cc78415">bound_mem_functor0</a> (T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__mem__functor0.html#a36b5479bfc091c063d44b11ad024393a">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a7de90a27f55055cae43df1425cc78415"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__mem__functor0.html" title="bound_mem_functor0 encapsulates a method with 0 arguments and an object instance.">bound_mem_functor0</a> object that wraps the passed method. <a href="classsigc_1_1bound__mem__functor0.html#a7de90a27f55055cae43df1425cc78415">More...</a><br /></td></tr>
+<tr class="separator:a7de90a27f55055cae43df1425cc78415"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8f0ea7caa1c5858b44ebdb0bcf4ba74a"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor0.html#a8f0ea7caa1c5858b44ebdb0bcf4ba74a">operator()</a> () const</td></tr>
+<tr class="memdesc:a8f0ea7caa1c5858b44ebdb0bcf4ba74a"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__mem__functor0.html#a8f0ea7caa1c5858b44ebdb0bcf4ba74a">More...</a><br /></td></tr>
+<tr class="separator:a8f0ea7caa1c5858b44ebdb0bcf4ba74a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1mem__functor0"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1mem__functor0')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1mem__functor0.html">sigc::mem_functor0< T_return, T_obj ></a></td></tr>
+<tr class="memitem:ad598cd301fc54f3aa4da2b9e3c16bc81 inherit pub_methods_classsigc_1_1mem__functor0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor0.html#ad598cd301fc54f3aa4da2b9e3c16bc81">mem_functor0</a> ()</td></tr>
+<tr class="memdesc:ad598cd301fc54f3aa4da2b9e3c16bc81 inherit pub_methods_classsigc_1_1mem__functor0"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1mem__functor0.html#ad598cd301fc54f3aa4da2b9e3c16bc81">More...</a><br /></td></tr>
+<tr class="separator:ad598cd301fc54f3aa4da2b9e3c16bc81 inherit pub_methods_classsigc_1_1mem__functor0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5655f48c6f36716dc15daf584f20d51c inherit pub_methods_classsigc_1_1mem__functor0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor0.html#a5655f48c6f36716dc15daf584f20d51c">mem_functor0</a> (<a class="el" href="classsigc_1_1mem__functor0.html#a2b54ee0f1d0b0ca4f25707c85a5d4bab">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a5655f48c6f36716dc15daf584f20d51c inherit pub_methods_classsigc_1_1mem__functor0"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1mem__functor0.html" title="mem_functor0 wraps methods with 0 argument(s).">mem_functor0</a> object that wraps the passed method. <a href="classsigc_1_1mem__functor0.html#a5655f48c6f36716dc15daf584f20d51c">More...</a><br /></td></tr>
+<tr class="separator:a5655f48c6f36716dc15daf584f20d51c inherit pub_methods_classsigc_1_1mem__functor0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a51d5213c9d41b51e3b8cca705bd801cc inherit pub_methods_classsigc_1_1mem__functor0"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor0.html#a51d5213c9d41b51e3b8cca705bd801cc">operator()</a> (T_obj & _A_obj) const</td></tr>
+<tr class="memdesc:a51d5213c9d41b51e3b8cca705bd801cc inherit pub_methods_classsigc_1_1mem__functor0"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor0.html#a51d5213c9d41b51e3b8cca705bd801cc">More...</a><br /></td></tr>
+<tr class="separator:a51d5213c9d41b51e3b8cca705bd801cc inherit pub_methods_classsigc_1_1mem__functor0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0a8b70a8f59ddbdc3f1a9892c634bf48 inherit pub_methods_classsigc_1_1mem__functor0"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor0.html#a0a8b70a8f59ddbdc3f1a9892c634bf48">operator()</a> (T_obj * _A_obj) const</td></tr>
+<tr class="memdesc:a0a8b70a8f59ddbdc3f1a9892c634bf48 inherit pub_methods_classsigc_1_1mem__functor0"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor0.html#a0a8b70a8f59ddbdc3f1a9892c634bf48">More...</a><br /></td></tr>
+<tr class="separator:a0a8b70a8f59ddbdc3f1a9892c634bf48 inherit pub_methods_classsigc_1_1mem__functor0"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:ae64f4c6596667228376947a38c4a8bb7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1limit__reference.html">limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor0.html#ae64f4c6596667228376947a38c4a8bb7">obj_</a></td></tr>
+<tr class="separator:ae64f4c6596667228376947a38c4a8bb7"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1mem__functor0"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1mem__functor0')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1mem__functor0.html">sigc::mem_functor0< T_return, T_obj ></a></td></tr>
+<tr class="memitem:a1f7b51d412900f55e155ecdd848fa283 inherit pro_attribs_classsigc_1_1mem__functor0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor0.html#a2b54ee0f1d0b0ca4f25707c85a5d4bab">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor0.html#a1f7b51d412900f55e155ecdd848fa283">func_ptr_</a></td></tr>
+<tr class="separator:a1f7b51d412900f55e155ecdd848fa283 inherit pro_attribs_classsigc_1_1mem__functor0"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj><br />
+class sigc::bound_mem_functor0< T_return, T_obj ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__mem__functor0.html" title="bound_mem_functor0 encapsulates a method with 0 arguments and an object instance.">bound_mem_functor0</a> encapsulates a method with 0 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__mem__functor0.html" title="bound_mem_functor0 encapsulates a method with 0 arguments and an object instance.">bound_mem_functor0</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__mem__functor0.html#a8f0ea7caa1c5858b44ebdb0bcf4ba74a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a36b5479bfc091c063d44b11ad024393a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a36b5479bfc091c063d44b11ad024393a">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__mem__functor0.html">sigc::bound_mem_functor0</a>< T_return, T_obj >::<a class="el" href="classsigc_1_1bound__mem__functor0.html#a36b5479bfc091c063d44b11ad024393a">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a7de90a27f55055cae43df1425cc78415"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7de90a27f55055cae43df1425cc78415">◆ </a></span>bound_mem_functor0() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor0.html">sigc::bound_mem_functor0</a>< T_return, T_obj >::<a class="el" href="classsigc_1_1bound__mem__functor0.html">bound_mem_functor0</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__mem__functor0.html#a36b5479bfc091c063d44b11ad024393a">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__mem__functor0.html" title="bound_mem_functor0 encapsulates a method with 0 arguments and an object instance.">bound_mem_functor0</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000162">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__mem__functor0.html#a8f0ea7caa1c5858b44ebdb0bcf4ba74a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a137ab7d3b66b421f664e154e3d01e66c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a137ab7d3b66b421f664e154e3d01e66c">◆ </a></span>bound_mem_functor0() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor0.html">sigc::bound_mem_functor0</a>< T_return, T_obj >::<a class="el" href="classsigc_1_1bound__mem__functor0.html">bound_mem_functor0</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__mem__functor0.html#a36b5479bfc091c063d44b11ad024393a">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__mem__functor0.html" title="bound_mem_functor0 encapsulates a method with 0 arguments and an object instance.">bound_mem_functor0</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__mem__functor0.html#a8f0ea7caa1c5858b44ebdb0bcf4ba74a" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a8f0ea7caa1c5858b44ebdb0bcf4ba74a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8f0ea7caa1c5858b44ebdb0bcf4ba74a">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__mem__functor0.html">sigc::bound_mem_functor0</a>< T_return, T_obj >::operator() </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="ae64f4c6596667228376947a38c4a8bb7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae64f4c6596667228376947a38c4a8bb7">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1limit__reference.html">limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__mem__functor0.html">sigc::bound_mem_functor0</a>< T_return, T_obj >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_mem_functor0< T_return, T_obj >" name="sigc::bound_mem_functor0< T_return, T_obj >">
+<area shape="rect" id="node1" title="bound_mem_functor0 encapsulates a method with 0 arguments and an object instance." alt="" coords="5,169,204,211"/>
+<area shape="rect" id="node2" href="$classsigc_1_1mem__functor0.html" title="mem_functor0 wraps methods with 0 argument(s)." alt="" coords="29,80,180,121"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="35,5,175,32"/>
+</map>
--- /dev/null
+6b22ff748922102dfec52c3e1ccd7588
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__mem__functor1.html">bound_mem_functor1</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_mem_functor1< T_return, T_obj, T_arg1 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__mem__functor1.html">sigc::bound_mem_functor1< T_return, T_obj, T_arg1 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor1.html#ad13235c20a9171bd24a4f8ae36577448">bound_mem_functor1</a>(T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor1.html">sigc::bound_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor1.html#a777afe4673c9adc0798a38fc96bca7f6">bound_mem_functor1</a>(T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor1.html">sigc::bound_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor1.html#af5981be86ea36d59e86234ef5cd2b5a4">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1mem__functor1.html">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor1.html#a8e460c2a0eb87dcaf263c984b4dc5888">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor1.html">sigc::bound_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor1.html#ab97c2206275025d8d1e7665c12322eba">mem_functor1</a>()</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor1.html">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor1.html#a63230b348e410f7d2f245df1f2af019a">mem_functor1</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor1.html">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor1.html#a95ae2c4525d8218569b68bbb3effbadf">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor1.html">sigc::bound_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor1.html#af9d43a802f122d38d264b3f662bcfe43">operator()</a>(type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor1.html">sigc::bound_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor1.html#a11fa461ba0bbddc9e5a7dd687e90591b">sigc::mem_functor1::operator()</a>(T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor1.html">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor1.html#a55a370a320def89e80aa37141c101c98">sigc::mem_functor1::operator()</a>(T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor1.html">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor1.html#a7c7ab28530e2f678eae87772253df709">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor1.html">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_mem_functor1< T_return, T_obj, T_arg1 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__mem__functor1.html">bound_mem_functor1</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__mem__functor1-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_mem_functor1< T_return, T_obj, T_arg1 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__mem__functor1.html" title="bound_mem_functor1 encapsulates a method with 1 arguments and an object instance.">bound_mem_functor1</a> encapsulates a method with 1 arguments and an object instance.
+ <a href="classsigc_1_1bound__mem__functor1.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_mem_functor1< T_return, T_obj, T_arg1 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__mem__functor1__inherit__graph.png" border="0" usemap="#asigc_1_1bound__mem__functor1_3_01T__return_00_01T__obj_00_01T__arg1_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__mem__functor1_3_01T__return_00_01T__obj_00_01T__arg1_01_4_inherit__map" id="asigc_1_1bound__mem__functor1_3_01T__return_00_01T__obj_00_01T__arg1_01_4_inherit__map">
+<area shape="rect" title="bound_mem_functor1 encapsulates a method with 1 arguments and an object instance." alt="" coords="5,184,207,225"/>
+<area shape="rect" href="classsigc_1_1mem__functor1.html" title="mem_functor1 wraps methods with 1 argument(s)." alt="" coords="31,80,181,136"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="36,5,176,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a8e460c2a0eb87dcaf263c984b4dc5888"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor1.html#a8e460c2a0eb87dcaf263c984b4dc5888">function_type</a></td></tr>
+<tr class="separator:a8e460c2a0eb87dcaf263c984b4dc5888"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1mem__functor1"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1mem__functor1')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1mem__functor1.html">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a></td></tr>
+<tr class="memitem:a4f10314fc4d7811e126aa0d8dc9fea8c inherit pub_types_classsigc_1_1mem__functor1"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor1.html#a4f10314fc4d7811e126aa0d8dc9fea8c">function_type</a>) (T_arg1)</td></tr>
+<tr class="separator:a4f10314fc4d7811e126aa0d8dc9fea8c inherit pub_types_classsigc_1_1mem__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7c7ab28530e2f678eae87772253df709 inherit pub_types_classsigc_1_1mem__functor1"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor1.html#a7c7ab28530e2f678eae87772253df709">result_type</a></td></tr>
+<tr class="separator:a7c7ab28530e2f678eae87772253df709 inherit pub_types_classsigc_1_1mem__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a777afe4673c9adc0798a38fc96bca7f6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor1.html#a777afe4673c9adc0798a38fc96bca7f6">bound_mem_functor1</a> (T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__mem__functor1.html#a8e460c2a0eb87dcaf263c984b4dc5888">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a777afe4673c9adc0798a38fc96bca7f6"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__mem__functor1.html" title="bound_mem_functor1 encapsulates a method with 1 arguments and an object instance.">bound_mem_functor1</a> object that wraps the passed method. <a href="classsigc_1_1bound__mem__functor1.html#a777afe4673c9adc0798a38fc96bca7f6">More...</a><br /></td></tr>
+<tr class="separator:a777afe4673c9adc0798a38fc96bca7f6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad13235c20a9171bd24a4f8ae36577448"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor1.html#ad13235c20a9171bd24a4f8ae36577448">bound_mem_functor1</a> (T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__mem__functor1.html#a8e460c2a0eb87dcaf263c984b4dc5888">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:ad13235c20a9171bd24a4f8ae36577448"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__mem__functor1.html" title="bound_mem_functor1 encapsulates a method with 1 arguments and an object instance.">bound_mem_functor1</a> object that wraps the passed method. <a href="classsigc_1_1bound__mem__functor1.html#ad13235c20a9171bd24a4f8ae36577448">More...</a><br /></td></tr>
+<tr class="separator:ad13235c20a9171bd24a4f8ae36577448"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af9d43a802f122d38d264b3f662bcfe43"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor1.html#af9d43a802f122d38d264b3f662bcfe43">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:af9d43a802f122d38d264b3f662bcfe43"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__mem__functor1.html#af9d43a802f122d38d264b3f662bcfe43">More...</a><br /></td></tr>
+<tr class="separator:af9d43a802f122d38d264b3f662bcfe43"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1mem__functor1"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1mem__functor1')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1mem__functor1.html">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a></td></tr>
+<tr class="memitem:ab97c2206275025d8d1e7665c12322eba inherit pub_methods_classsigc_1_1mem__functor1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor1.html#ab97c2206275025d8d1e7665c12322eba">mem_functor1</a> ()</td></tr>
+<tr class="memdesc:ab97c2206275025d8d1e7665c12322eba inherit pub_methods_classsigc_1_1mem__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1mem__functor1.html#ab97c2206275025d8d1e7665c12322eba">More...</a><br /></td></tr>
+<tr class="separator:ab97c2206275025d8d1e7665c12322eba inherit pub_methods_classsigc_1_1mem__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a63230b348e410f7d2f245df1f2af019a inherit pub_methods_classsigc_1_1mem__functor1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor1.html#a63230b348e410f7d2f245df1f2af019a">mem_functor1</a> (<a class="el" href="classsigc_1_1mem__functor1.html#a4f10314fc4d7811e126aa0d8dc9fea8c">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a63230b348e410f7d2f245df1f2af019a inherit pub_methods_classsigc_1_1mem__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1mem__functor1.html" title="mem_functor1 wraps methods with 1 argument(s).">mem_functor1</a> object that wraps the passed method. <a href="classsigc_1_1mem__functor1.html#a63230b348e410f7d2f245df1f2af019a">More...</a><br /></td></tr>
+<tr class="separator:a63230b348e410f7d2f245df1f2af019a inherit pub_methods_classsigc_1_1mem__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a55a370a320def89e80aa37141c101c98 inherit pub_methods_classsigc_1_1mem__functor1"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor1.html#a55a370a320def89e80aa37141c101c98">operator()</a> (T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a55a370a320def89e80aa37141c101c98 inherit pub_methods_classsigc_1_1mem__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor1.html#a55a370a320def89e80aa37141c101c98">More...</a><br /></td></tr>
+<tr class="separator:a55a370a320def89e80aa37141c101c98 inherit pub_methods_classsigc_1_1mem__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a11fa461ba0bbddc9e5a7dd687e90591b inherit pub_methods_classsigc_1_1mem__functor1"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor1.html#a11fa461ba0bbddc9e5a7dd687e90591b">operator()</a> (T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a11fa461ba0bbddc9e5a7dd687e90591b inherit pub_methods_classsigc_1_1mem__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor1.html#a11fa461ba0bbddc9e5a7dd687e90591b">More...</a><br /></td></tr>
+<tr class="separator:a11fa461ba0bbddc9e5a7dd687e90591b inherit pub_methods_classsigc_1_1mem__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:a95ae2c4525d8218569b68bbb3effbadf"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1limit__reference.html">limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor1.html#a95ae2c4525d8218569b68bbb3effbadf">obj_</a></td></tr>
+<tr class="separator:a95ae2c4525d8218569b68bbb3effbadf"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1mem__functor1"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1mem__functor1')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1mem__functor1.html">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a></td></tr>
+<tr class="memitem:af5981be86ea36d59e86234ef5cd2b5a4 inherit pro_attribs_classsigc_1_1mem__functor1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor1.html#a4f10314fc4d7811e126aa0d8dc9fea8c">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor1.html#af5981be86ea36d59e86234ef5cd2b5a4">func_ptr_</a></td></tr>
+<tr class="separator:af5981be86ea36d59e86234ef5cd2b5a4 inherit pro_attribs_classsigc_1_1mem__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1><br />
+class sigc::bound_mem_functor1< T_return, T_obj, T_arg1 ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__mem__functor1.html" title="bound_mem_functor1 encapsulates a method with 1 arguments and an object instance.">bound_mem_functor1</a> encapsulates a method with 1 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__mem__functor1.html" title="bound_mem_functor1 encapsulates a method with 1 arguments and an object instance.">bound_mem_functor1</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__mem__functor1.html#af9d43a802f122d38d264b3f662bcfe43" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__mem__functor1.html#af9d43a802f122d38d264b3f662bcfe43" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a8e460c2a0eb87dcaf263c984b4dc5888"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8e460c2a0eb87dcaf263c984b4dc5888">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__mem__functor1.html">sigc::bound_mem_functor1</a>< T_return, T_obj, T_arg1 >::<a class="el" href="classsigc_1_1bound__mem__functor1.html#a8e460c2a0eb87dcaf263c984b4dc5888">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="ad13235c20a9171bd24a4f8ae36577448"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad13235c20a9171bd24a4f8ae36577448">◆ </a></span>bound_mem_functor1() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor1.html">sigc::bound_mem_functor1</a>< T_return, T_obj, T_arg1 >::<a class="el" href="classsigc_1_1bound__mem__functor1.html">bound_mem_functor1</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__mem__functor1.html#a8e460c2a0eb87dcaf263c984b4dc5888">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__mem__functor1.html" title="bound_mem_functor1 encapsulates a method with 1 arguments and an object instance.">bound_mem_functor1</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000163">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__mem__functor1.html#af9d43a802f122d38d264b3f662bcfe43" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a777afe4673c9adc0798a38fc96bca7f6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a777afe4673c9adc0798a38fc96bca7f6">◆ </a></span>bound_mem_functor1() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor1.html">sigc::bound_mem_functor1</a>< T_return, T_obj, T_arg1 >::<a class="el" href="classsigc_1_1bound__mem__functor1.html">bound_mem_functor1</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__mem__functor1.html#a8e460c2a0eb87dcaf263c984b4dc5888">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__mem__functor1.html" title="bound_mem_functor1 encapsulates a method with 1 arguments and an object instance.">bound_mem_functor1</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__mem__functor1.html#af9d43a802f122d38d264b3f662bcfe43" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="af9d43a802f122d38d264b3f662bcfe43"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af9d43a802f122d38d264b3f662bcfe43">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__mem__functor1.html">sigc::bound_mem_functor1</a>< T_return, T_obj, T_arg1 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a95ae2c4525d8218569b68bbb3effbadf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a95ae2c4525d8218569b68bbb3effbadf">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1limit__reference.html">limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__mem__functor1.html">sigc::bound_mem_functor1</a>< T_return, T_obj, T_arg1 >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_mem_functor1< T_return, T_obj, T_arg1 >" name="sigc::bound_mem_functor1< T_return, T_obj, T_arg1 >">
+<area shape="rect" id="node1" title="bound_mem_functor1 encapsulates a method with 1 arguments and an object instance." alt="" coords="5,184,207,225"/>
+<area shape="rect" id="node2" href="$classsigc_1_1mem__functor1.html" title="mem_functor1 wraps methods with 1 argument(s)." alt="" coords="31,80,181,136"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="36,5,176,32"/>
+</map>
--- /dev/null
+63a0c7d6e99a32fee58eea7ff7fa6a1c
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__mem__functor2.html">bound_mem_functor2</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__mem__functor2.html">sigc::bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor2.html#a48bc9b34469749461813061d17680ca2">bound_mem_functor2</a>(T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor2.html">sigc::bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor2.html#a830746b33cae370b756334e4a8cab703">bound_mem_functor2</a>(T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor2.html">sigc::bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor2.html#aa4b00e1d6bb65c1c1791d314b5dcb4d6">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1mem__functor2.html">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor2.html#a1b0b5d2145f50d19214ff41bd45ab978">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor2.html">sigc::bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor2.html#a691e21d47b7a54b67605812f7e089299">mem_functor2</a>()</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor2.html">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor2.html#aeee1c7f263f8d7e7b6fa9be0156878fe">mem_functor2</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor2.html">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor2.html#a423780eab9a560771ec3266ea0693117">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor2.html">sigc::bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor2.html#a09d48d61cc092e3f12c8ac4df4449596">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor2.html">sigc::bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor2.html#ad5d0f74803537d1ed8b9678ac2da57d5">sigc::mem_functor2::operator()</a>(T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor2.html">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor2.html#a6fe02ecb626919c1149888b03fde552e">sigc::mem_functor2::operator()</a>(T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor2.html">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor2.html#a9080e942d35d226ea6f9dda097342f07">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor2.html">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__mem__functor2.html">bound_mem_functor2</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__mem__functor2-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__mem__functor2.html" title="bound_mem_functor2 encapsulates a method with 2 arguments and an object instance.">bound_mem_functor2</a> encapsulates a method with 2 arguments and an object instance.
+ <a href="classsigc_1_1bound__mem__functor2.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__mem__functor2__inherit__graph.png" border="0" usemap="#asigc_1_1bound__mem__functor2_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__mem__functor2_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_01_4_inherit__map" id="asigc_1_1bound__mem__functor2_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_01_4_inherit__map">
+<area shape="rect" title="bound_mem_functor2 encapsulates a method with 2 arguments and an object instance." alt="" coords="5,184,204,240"/>
+<area shape="rect" href="classsigc_1_1mem__functor2.html" title="mem_functor2 wraps methods with 2 argument(s)." alt="" coords="29,80,180,136"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="35,5,175,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a1b0b5d2145f50d19214ff41bd45ab978"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor2.html#a1b0b5d2145f50d19214ff41bd45ab978">function_type</a></td></tr>
+<tr class="separator:a1b0b5d2145f50d19214ff41bd45ab978"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1mem__functor2"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1mem__functor2')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1mem__functor2.html">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td></tr>
+<tr class="memitem:aa584cfe15bb8dc5b2931d2bfd034c118 inherit pub_types_classsigc_1_1mem__functor2"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor2.html#aa584cfe15bb8dc5b2931d2bfd034c118">function_type</a>) (T_arg1, T_arg2)</td></tr>
+<tr class="separator:aa584cfe15bb8dc5b2931d2bfd034c118 inherit pub_types_classsigc_1_1mem__functor2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9080e942d35d226ea6f9dda097342f07 inherit pub_types_classsigc_1_1mem__functor2"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor2.html#a9080e942d35d226ea6f9dda097342f07">result_type</a></td></tr>
+<tr class="separator:a9080e942d35d226ea6f9dda097342f07 inherit pub_types_classsigc_1_1mem__functor2"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a830746b33cae370b756334e4a8cab703"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor2.html#a830746b33cae370b756334e4a8cab703">bound_mem_functor2</a> (T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__mem__functor2.html#a1b0b5d2145f50d19214ff41bd45ab978">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a830746b33cae370b756334e4a8cab703"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__mem__functor2.html" title="bound_mem_functor2 encapsulates a method with 2 arguments and an object instance.">bound_mem_functor2</a> object that wraps the passed method. <a href="classsigc_1_1bound__mem__functor2.html#a830746b33cae370b756334e4a8cab703">More...</a><br /></td></tr>
+<tr class="separator:a830746b33cae370b756334e4a8cab703"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a48bc9b34469749461813061d17680ca2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor2.html#a48bc9b34469749461813061d17680ca2">bound_mem_functor2</a> (T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__mem__functor2.html#a1b0b5d2145f50d19214ff41bd45ab978">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a48bc9b34469749461813061d17680ca2"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__mem__functor2.html" title="bound_mem_functor2 encapsulates a method with 2 arguments and an object instance.">bound_mem_functor2</a> object that wraps the passed method. <a href="classsigc_1_1bound__mem__functor2.html#a48bc9b34469749461813061d17680ca2">More...</a><br /></td></tr>
+<tr class="separator:a48bc9b34469749461813061d17680ca2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a09d48d61cc092e3f12c8ac4df4449596"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor2.html#a09d48d61cc092e3f12c8ac4df4449596">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:a09d48d61cc092e3f12c8ac4df4449596"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__mem__functor2.html#a09d48d61cc092e3f12c8ac4df4449596">More...</a><br /></td></tr>
+<tr class="separator:a09d48d61cc092e3f12c8ac4df4449596"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1mem__functor2"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1mem__functor2')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1mem__functor2.html">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td></tr>
+<tr class="memitem:a691e21d47b7a54b67605812f7e089299 inherit pub_methods_classsigc_1_1mem__functor2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor2.html#a691e21d47b7a54b67605812f7e089299">mem_functor2</a> ()</td></tr>
+<tr class="memdesc:a691e21d47b7a54b67605812f7e089299 inherit pub_methods_classsigc_1_1mem__functor2"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1mem__functor2.html#a691e21d47b7a54b67605812f7e089299">More...</a><br /></td></tr>
+<tr class="separator:a691e21d47b7a54b67605812f7e089299 inherit pub_methods_classsigc_1_1mem__functor2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aeee1c7f263f8d7e7b6fa9be0156878fe inherit pub_methods_classsigc_1_1mem__functor2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor2.html#aeee1c7f263f8d7e7b6fa9be0156878fe">mem_functor2</a> (<a class="el" href="classsigc_1_1mem__functor2.html#aa584cfe15bb8dc5b2931d2bfd034c118">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:aeee1c7f263f8d7e7b6fa9be0156878fe inherit pub_methods_classsigc_1_1mem__functor2"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1mem__functor2.html" title="mem_functor2 wraps methods with 2 argument(s).">mem_functor2</a> object that wraps the passed method. <a href="classsigc_1_1mem__functor2.html#aeee1c7f263f8d7e7b6fa9be0156878fe">More...</a><br /></td></tr>
+<tr class="separator:aeee1c7f263f8d7e7b6fa9be0156878fe inherit pub_methods_classsigc_1_1mem__functor2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a6fe02ecb626919c1149888b03fde552e inherit pub_methods_classsigc_1_1mem__functor2"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor2.html#a6fe02ecb626919c1149888b03fde552e">operator()</a> (T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:a6fe02ecb626919c1149888b03fde552e inherit pub_methods_classsigc_1_1mem__functor2"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor2.html#a6fe02ecb626919c1149888b03fde552e">More...</a><br /></td></tr>
+<tr class="separator:a6fe02ecb626919c1149888b03fde552e inherit pub_methods_classsigc_1_1mem__functor2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad5d0f74803537d1ed8b9678ac2da57d5 inherit pub_methods_classsigc_1_1mem__functor2"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor2.html#ad5d0f74803537d1ed8b9678ac2da57d5">operator()</a> (T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:ad5d0f74803537d1ed8b9678ac2da57d5 inherit pub_methods_classsigc_1_1mem__functor2"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor2.html#ad5d0f74803537d1ed8b9678ac2da57d5">More...</a><br /></td></tr>
+<tr class="separator:ad5d0f74803537d1ed8b9678ac2da57d5 inherit pub_methods_classsigc_1_1mem__functor2"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:a423780eab9a560771ec3266ea0693117"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1limit__reference.html">limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor2.html#a423780eab9a560771ec3266ea0693117">obj_</a></td></tr>
+<tr class="separator:a423780eab9a560771ec3266ea0693117"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1mem__functor2"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1mem__functor2')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1mem__functor2.html">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td></tr>
+<tr class="memitem:aa4b00e1d6bb65c1c1791d314b5dcb4d6 inherit pro_attribs_classsigc_1_1mem__functor2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor2.html#aa584cfe15bb8dc5b2931d2bfd034c118">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor2.html#aa4b00e1d6bb65c1c1791d314b5dcb4d6">func_ptr_</a></td></tr>
+<tr class="separator:aa4b00e1d6bb65c1c1791d314b5dcb4d6 inherit pro_attribs_classsigc_1_1mem__functor2"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2><br />
+class sigc::bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__mem__functor2.html" title="bound_mem_functor2 encapsulates a method with 2 arguments and an object instance.">bound_mem_functor2</a> encapsulates a method with 2 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__mem__functor2.html" title="bound_mem_functor2 encapsulates a method with 2 arguments and an object instance.">bound_mem_functor2</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__mem__functor2.html#a09d48d61cc092e3f12c8ac4df4449596" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__mem__functor2.html#a09d48d61cc092e3f12c8ac4df4449596" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__mem__functor2.html#a09d48d61cc092e3f12c8ac4df4449596" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a1b0b5d2145f50d19214ff41bd45ab978"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1b0b5d2145f50d19214ff41bd45ab978">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__mem__functor2.html">sigc::bound_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1bound__mem__functor2.html#a1b0b5d2145f50d19214ff41bd45ab978">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a48bc9b34469749461813061d17680ca2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a48bc9b34469749461813061d17680ca2">◆ </a></span>bound_mem_functor2() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor2.html">sigc::bound_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1bound__mem__functor2.html">bound_mem_functor2</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__mem__functor2.html#a1b0b5d2145f50d19214ff41bd45ab978">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__mem__functor2.html" title="bound_mem_functor2 encapsulates a method with 2 arguments and an object instance.">bound_mem_functor2</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000164">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__mem__functor2.html#a09d48d61cc092e3f12c8ac4df4449596" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a830746b33cae370b756334e4a8cab703"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a830746b33cae370b756334e4a8cab703">◆ </a></span>bound_mem_functor2() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor2.html">sigc::bound_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1bound__mem__functor2.html">bound_mem_functor2</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__mem__functor2.html#a1b0b5d2145f50d19214ff41bd45ab978">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__mem__functor2.html" title="bound_mem_functor2 encapsulates a method with 2 arguments and an object instance.">bound_mem_functor2</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__mem__functor2.html#a09d48d61cc092e3f12c8ac4df4449596" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a09d48d61cc092e3f12c8ac4df4449596"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a09d48d61cc092e3f12c8ac4df4449596">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__mem__functor2.html">sigc::bound_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a423780eab9a560771ec3266ea0693117"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a423780eab9a560771ec3266ea0693117">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1limit__reference.html">limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__mem__functor2.html">sigc::bound_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >" name="sigc::bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >">
+<area shape="rect" id="node1" title="bound_mem_functor2 encapsulates a method with 2 arguments and an object instance." alt="" coords="5,184,204,240"/>
+<area shape="rect" id="node2" href="$classsigc_1_1mem__functor2.html" title="mem_functor2 wraps methods with 2 argument(s)." alt="" coords="29,80,180,136"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="35,5,175,32"/>
+</map>
--- /dev/null
+694a4eac068e9cadfafd5ed3caf83776
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__mem__functor3.html">bound_mem_functor3</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__mem__functor3.html">sigc::bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor3.html#aadbbb586e3ba0c44a25c1f3834c4c438">bound_mem_functor3</a>(T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor3.html">sigc::bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor3.html#a1d1dddd6a334864611f5dc3a8ece26f9">bound_mem_functor3</a>(T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor3.html">sigc::bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor3.html#ac7ed881bf6b6ef8c7ed418ad3bfc0ccc">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1mem__functor3.html">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor3.html#a66d1aa7ad3edafd8851ee0b334f83efe">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor3.html">sigc::bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor3.html#abc94be96c346537bca09c73a342f5ccd">mem_functor3</a>()</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor3.html">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor3.html#af22e274e905262144832ca9683d8823f">mem_functor3</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor3.html">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor3.html#ae05cea0cbd3345abc624e545422bb47a">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor3.html">sigc::bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor3.html#aa61ed1a1c920069032ffd5427d24a771">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor3.html">sigc::bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor3.html#ae7496f451661d60b287d528a7cfcaf82">sigc::mem_functor3::operator()</a>(T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor3.html">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor3.html#a12319d24e245cf126c130de8202d91bf">sigc::mem_functor3::operator()</a>(T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor3.html">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor3.html#af620103fa36aa86fb539843f7f730e01">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor3.html">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__mem__functor3.html">bound_mem_functor3</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__mem__functor3-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__mem__functor3.html" title="bound_mem_functor3 encapsulates a method with 3 arguments and an object instance.">bound_mem_functor3</a> encapsulates a method with 3 arguments and an object instance.
+ <a href="classsigc_1_1bound__mem__functor3.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__mem__functor3__inherit__graph.png" border="0" usemap="#asigc_1_1bound__mem__functor3_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__mem__functor3_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_01_4_inherit__map" id="asigc_1_1bound__mem__functor3_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_01_4_inherit__map">
+<area shape="rect" title="bound_mem_functor3 encapsulates a method with 3 arguments and an object instance." alt="" coords="5,184,204,240"/>
+<area shape="rect" href="classsigc_1_1mem__functor3.html" title="mem_functor3 wraps methods with 3 argument(s)." alt="" coords="16,80,193,136"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="35,5,175,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a66d1aa7ad3edafd8851ee0b334f83efe"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor3.html#a66d1aa7ad3edafd8851ee0b334f83efe">function_type</a></td></tr>
+<tr class="separator:a66d1aa7ad3edafd8851ee0b334f83efe"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1mem__functor3"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1mem__functor3')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1mem__functor3.html">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td></tr>
+<tr class="memitem:a8da99a5dcfe5ae1cecd6ce93ab91b929 inherit pub_types_classsigc_1_1mem__functor3"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor3.html#a8da99a5dcfe5ae1cecd6ce93ab91b929">function_type</a>) (T_arg1, T_arg2, T_arg3)</td></tr>
+<tr class="separator:a8da99a5dcfe5ae1cecd6ce93ab91b929 inherit pub_types_classsigc_1_1mem__functor3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af620103fa36aa86fb539843f7f730e01 inherit pub_types_classsigc_1_1mem__functor3"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor3.html#af620103fa36aa86fb539843f7f730e01">result_type</a></td></tr>
+<tr class="separator:af620103fa36aa86fb539843f7f730e01 inherit pub_types_classsigc_1_1mem__functor3"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a1d1dddd6a334864611f5dc3a8ece26f9"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor3.html#a1d1dddd6a334864611f5dc3a8ece26f9">bound_mem_functor3</a> (T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__mem__functor3.html#a66d1aa7ad3edafd8851ee0b334f83efe">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a1d1dddd6a334864611f5dc3a8ece26f9"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__mem__functor3.html" title="bound_mem_functor3 encapsulates a method with 3 arguments and an object instance.">bound_mem_functor3</a> object that wraps the passed method. <a href="classsigc_1_1bound__mem__functor3.html#a1d1dddd6a334864611f5dc3a8ece26f9">More...</a><br /></td></tr>
+<tr class="separator:a1d1dddd6a334864611f5dc3a8ece26f9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aadbbb586e3ba0c44a25c1f3834c4c438"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor3.html#aadbbb586e3ba0c44a25c1f3834c4c438">bound_mem_functor3</a> (T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__mem__functor3.html#a66d1aa7ad3edafd8851ee0b334f83efe">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:aadbbb586e3ba0c44a25c1f3834c4c438"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__mem__functor3.html" title="bound_mem_functor3 encapsulates a method with 3 arguments and an object instance.">bound_mem_functor3</a> object that wraps the passed method. <a href="classsigc_1_1bound__mem__functor3.html#aadbbb586e3ba0c44a25c1f3834c4c438">More...</a><br /></td></tr>
+<tr class="separator:aadbbb586e3ba0c44a25c1f3834c4c438"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa61ed1a1c920069032ffd5427d24a771"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor3.html#aa61ed1a1c920069032ffd5427d24a771">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:aa61ed1a1c920069032ffd5427d24a771"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__mem__functor3.html#aa61ed1a1c920069032ffd5427d24a771">More...</a><br /></td></tr>
+<tr class="separator:aa61ed1a1c920069032ffd5427d24a771"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1mem__functor3"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1mem__functor3')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1mem__functor3.html">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td></tr>
+<tr class="memitem:abc94be96c346537bca09c73a342f5ccd inherit pub_methods_classsigc_1_1mem__functor3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor3.html#abc94be96c346537bca09c73a342f5ccd">mem_functor3</a> ()</td></tr>
+<tr class="memdesc:abc94be96c346537bca09c73a342f5ccd inherit pub_methods_classsigc_1_1mem__functor3"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1mem__functor3.html#abc94be96c346537bca09c73a342f5ccd">More...</a><br /></td></tr>
+<tr class="separator:abc94be96c346537bca09c73a342f5ccd inherit pub_methods_classsigc_1_1mem__functor3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af22e274e905262144832ca9683d8823f inherit pub_methods_classsigc_1_1mem__functor3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor3.html#af22e274e905262144832ca9683d8823f">mem_functor3</a> (<a class="el" href="classsigc_1_1mem__functor3.html#a8da99a5dcfe5ae1cecd6ce93ab91b929">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:af22e274e905262144832ca9683d8823f inherit pub_methods_classsigc_1_1mem__functor3"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1mem__functor3.html" title="mem_functor3 wraps methods with 3 argument(s).">mem_functor3</a> object that wraps the passed method. <a href="classsigc_1_1mem__functor3.html#af22e274e905262144832ca9683d8823f">More...</a><br /></td></tr>
+<tr class="separator:af22e274e905262144832ca9683d8823f inherit pub_methods_classsigc_1_1mem__functor3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a12319d24e245cf126c130de8202d91bf inherit pub_methods_classsigc_1_1mem__functor3"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor3.html#a12319d24e245cf126c130de8202d91bf">operator()</a> (T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:a12319d24e245cf126c130de8202d91bf inherit pub_methods_classsigc_1_1mem__functor3"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor3.html#a12319d24e245cf126c130de8202d91bf">More...</a><br /></td></tr>
+<tr class="separator:a12319d24e245cf126c130de8202d91bf inherit pub_methods_classsigc_1_1mem__functor3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae7496f451661d60b287d528a7cfcaf82 inherit pub_methods_classsigc_1_1mem__functor3"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor3.html#ae7496f451661d60b287d528a7cfcaf82">operator()</a> (T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:ae7496f451661d60b287d528a7cfcaf82 inherit pub_methods_classsigc_1_1mem__functor3"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor3.html#ae7496f451661d60b287d528a7cfcaf82">More...</a><br /></td></tr>
+<tr class="separator:ae7496f451661d60b287d528a7cfcaf82 inherit pub_methods_classsigc_1_1mem__functor3"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:ae05cea0cbd3345abc624e545422bb47a"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1limit__reference.html">limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor3.html#ae05cea0cbd3345abc624e545422bb47a">obj_</a></td></tr>
+<tr class="separator:ae05cea0cbd3345abc624e545422bb47a"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1mem__functor3"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1mem__functor3')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1mem__functor3.html">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td></tr>
+<tr class="memitem:ac7ed881bf6b6ef8c7ed418ad3bfc0ccc inherit pro_attribs_classsigc_1_1mem__functor3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor3.html#a8da99a5dcfe5ae1cecd6ce93ab91b929">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor3.html#ac7ed881bf6b6ef8c7ed418ad3bfc0ccc">func_ptr_</a></td></tr>
+<tr class="separator:ac7ed881bf6b6ef8c7ed418ad3bfc0ccc inherit pro_attribs_classsigc_1_1mem__functor3"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3><br />
+class sigc::bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__mem__functor3.html" title="bound_mem_functor3 encapsulates a method with 3 arguments and an object instance.">bound_mem_functor3</a> encapsulates a method with 3 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__mem__functor3.html" title="bound_mem_functor3 encapsulates a method with 3 arguments and an object instance.">bound_mem_functor3</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__mem__functor3.html#aa61ed1a1c920069032ffd5427d24a771" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__mem__functor3.html#aa61ed1a1c920069032ffd5427d24a771" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__mem__functor3.html#aa61ed1a1c920069032ffd5427d24a771" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__mem__functor3.html#aa61ed1a1c920069032ffd5427d24a771" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a66d1aa7ad3edafd8851ee0b334f83efe"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a66d1aa7ad3edafd8851ee0b334f83efe">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__mem__functor3.html">sigc::bound_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1bound__mem__functor3.html#a66d1aa7ad3edafd8851ee0b334f83efe">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="aadbbb586e3ba0c44a25c1f3834c4c438"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aadbbb586e3ba0c44a25c1f3834c4c438">◆ </a></span>bound_mem_functor3() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor3.html">sigc::bound_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1bound__mem__functor3.html">bound_mem_functor3</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__mem__functor3.html#a66d1aa7ad3edafd8851ee0b334f83efe">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__mem__functor3.html" title="bound_mem_functor3 encapsulates a method with 3 arguments and an object instance.">bound_mem_functor3</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000165">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__mem__functor3.html#aa61ed1a1c920069032ffd5427d24a771" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a1d1dddd6a334864611f5dc3a8ece26f9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1d1dddd6a334864611f5dc3a8ece26f9">◆ </a></span>bound_mem_functor3() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor3.html">sigc::bound_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1bound__mem__functor3.html">bound_mem_functor3</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__mem__functor3.html#a66d1aa7ad3edafd8851ee0b334f83efe">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__mem__functor3.html" title="bound_mem_functor3 encapsulates a method with 3 arguments and an object instance.">bound_mem_functor3</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__mem__functor3.html#aa61ed1a1c920069032ffd5427d24a771" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="aa61ed1a1c920069032ffd5427d24a771"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa61ed1a1c920069032ffd5427d24a771">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__mem__functor3.html">sigc::bound_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="ae05cea0cbd3345abc624e545422bb47a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae05cea0cbd3345abc624e545422bb47a">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1limit__reference.html">limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__mem__functor3.html">sigc::bound_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >" name="sigc::bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >">
+<area shape="rect" id="node1" title="bound_mem_functor3 encapsulates a method with 3 arguments and an object instance." alt="" coords="5,184,204,240"/>
+<area shape="rect" id="node2" href="$classsigc_1_1mem__functor3.html" title="mem_functor3 wraps methods with 3 argument(s)." alt="" coords="16,80,193,136"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="35,5,175,32"/>
+</map>
--- /dev/null
+ae2ef75f49610ba0ed0fe4e52df9eb71
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__mem__functor4.html">bound_mem_functor4</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__mem__functor4.html">sigc::bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor4.html#a15b592122574775dd2c4804617e1e3dd">bound_mem_functor4</a>(T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor4.html">sigc::bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor4.html#ae15ccaa9f58865b2cd9929644aa85612">bound_mem_functor4</a>(T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor4.html">sigc::bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor4.html#a28282d9285ca1a2075fd8041905a6302">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1mem__functor4.html">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor4.html#aeddcfc0ce5fe38259608bfc88af37568">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor4.html">sigc::bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor4.html#a9774f0ab47d023f5bccdb9960c4fcdee">mem_functor4</a>()</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor4.html">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor4.html#a4f7841b2ccd26fac6c21bf04fc524e08">mem_functor4</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor4.html">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor4.html#aa9a90c28652fb499438e757cdc6f3be7">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor4.html">sigc::bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor4.html#a0a9d2fb52ef15ae8d4e56238217c0539">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor4.html">sigc::bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor4.html#aef140dac7b4876793fac8a006aad0a62">sigc::mem_functor4::operator()</a>(T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor4.html">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor4.html#a37b49e119c9be15f15362fe44eadc6a2">sigc::mem_functor4::operator()</a>(T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor4.html">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor4.html#a79bf0a3c25dbe6eb07829ee55ce5d664">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor4.html">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__mem__functor4.html">bound_mem_functor4</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__mem__functor4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__mem__functor4.html" title="bound_mem_functor4 encapsulates a method with 4 arguments and an object instance.">bound_mem_functor4</a> encapsulates a method with 4 arguments and an object instance.
+ <a href="classsigc_1_1bound__mem__functor4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__mem__functor4__inherit__graph.png" border="0" usemap="#asigc_1_1bound__mem__functor4_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__mem__functor4_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_01_4_inherit__map" id="asigc_1_1bound__mem__functor4_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_01_4_inherit__map">
+<area shape="rect" title="bound_mem_functor4 encapsulates a method with 4 arguments and an object instance." alt="" coords="5,199,204,255"/>
+<area shape="rect" href="classsigc_1_1mem__functor4.html" title="mem_functor4 wraps methods with 4 argument(s)." alt="" coords="21,80,188,151"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="35,5,175,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:aeddcfc0ce5fe38259608bfc88af37568"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor4.html#aeddcfc0ce5fe38259608bfc88af37568">function_type</a></td></tr>
+<tr class="separator:aeddcfc0ce5fe38259608bfc88af37568"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1mem__functor4"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1mem__functor4')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1mem__functor4.html">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td></tr>
+<tr class="memitem:a9dcf1ef95187c2588ecf2abb089cc7c8 inherit pub_types_classsigc_1_1mem__functor4"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor4.html#a9dcf1ef95187c2588ecf2abb089cc7c8">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4)</td></tr>
+<tr class="separator:a9dcf1ef95187c2588ecf2abb089cc7c8 inherit pub_types_classsigc_1_1mem__functor4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a79bf0a3c25dbe6eb07829ee55ce5d664 inherit pub_types_classsigc_1_1mem__functor4"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor4.html#a79bf0a3c25dbe6eb07829ee55ce5d664">result_type</a></td></tr>
+<tr class="separator:a79bf0a3c25dbe6eb07829ee55ce5d664 inherit pub_types_classsigc_1_1mem__functor4"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:ae15ccaa9f58865b2cd9929644aa85612"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor4.html#ae15ccaa9f58865b2cd9929644aa85612">bound_mem_functor4</a> (T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__mem__functor4.html#aeddcfc0ce5fe38259608bfc88af37568">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:ae15ccaa9f58865b2cd9929644aa85612"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__mem__functor4.html" title="bound_mem_functor4 encapsulates a method with 4 arguments and an object instance.">bound_mem_functor4</a> object that wraps the passed method. <a href="classsigc_1_1bound__mem__functor4.html#ae15ccaa9f58865b2cd9929644aa85612">More...</a><br /></td></tr>
+<tr class="separator:ae15ccaa9f58865b2cd9929644aa85612"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a15b592122574775dd2c4804617e1e3dd"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor4.html#a15b592122574775dd2c4804617e1e3dd">bound_mem_functor4</a> (T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__mem__functor4.html#aeddcfc0ce5fe38259608bfc88af37568">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a15b592122574775dd2c4804617e1e3dd"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__mem__functor4.html" title="bound_mem_functor4 encapsulates a method with 4 arguments and an object instance.">bound_mem_functor4</a> object that wraps the passed method. <a href="classsigc_1_1bound__mem__functor4.html#a15b592122574775dd2c4804617e1e3dd">More...</a><br /></td></tr>
+<tr class="separator:a15b592122574775dd2c4804617e1e3dd"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0a9d2fb52ef15ae8d4e56238217c0539"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor4.html#a0a9d2fb52ef15ae8d4e56238217c0539">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:a0a9d2fb52ef15ae8d4e56238217c0539"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__mem__functor4.html#a0a9d2fb52ef15ae8d4e56238217c0539">More...</a><br /></td></tr>
+<tr class="separator:a0a9d2fb52ef15ae8d4e56238217c0539"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1mem__functor4"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1mem__functor4')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1mem__functor4.html">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td></tr>
+<tr class="memitem:a9774f0ab47d023f5bccdb9960c4fcdee inherit pub_methods_classsigc_1_1mem__functor4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor4.html#a9774f0ab47d023f5bccdb9960c4fcdee">mem_functor4</a> ()</td></tr>
+<tr class="memdesc:a9774f0ab47d023f5bccdb9960c4fcdee inherit pub_methods_classsigc_1_1mem__functor4"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1mem__functor4.html#a9774f0ab47d023f5bccdb9960c4fcdee">More...</a><br /></td></tr>
+<tr class="separator:a9774f0ab47d023f5bccdb9960c4fcdee inherit pub_methods_classsigc_1_1mem__functor4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4f7841b2ccd26fac6c21bf04fc524e08 inherit pub_methods_classsigc_1_1mem__functor4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor4.html#a4f7841b2ccd26fac6c21bf04fc524e08">mem_functor4</a> (<a class="el" href="classsigc_1_1mem__functor4.html#a9dcf1ef95187c2588ecf2abb089cc7c8">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a4f7841b2ccd26fac6c21bf04fc524e08 inherit pub_methods_classsigc_1_1mem__functor4"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1mem__functor4.html" title="mem_functor4 wraps methods with 4 argument(s).">mem_functor4</a> object that wraps the passed method. <a href="classsigc_1_1mem__functor4.html#a4f7841b2ccd26fac6c21bf04fc524e08">More...</a><br /></td></tr>
+<tr class="separator:a4f7841b2ccd26fac6c21bf04fc524e08 inherit pub_methods_classsigc_1_1mem__functor4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a37b49e119c9be15f15362fe44eadc6a2 inherit pub_methods_classsigc_1_1mem__functor4"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor4.html#a37b49e119c9be15f15362fe44eadc6a2">operator()</a> (T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:a37b49e119c9be15f15362fe44eadc6a2 inherit pub_methods_classsigc_1_1mem__functor4"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor4.html#a37b49e119c9be15f15362fe44eadc6a2">More...</a><br /></td></tr>
+<tr class="separator:a37b49e119c9be15f15362fe44eadc6a2 inherit pub_methods_classsigc_1_1mem__functor4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aef140dac7b4876793fac8a006aad0a62 inherit pub_methods_classsigc_1_1mem__functor4"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor4.html#aef140dac7b4876793fac8a006aad0a62">operator()</a> (T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:aef140dac7b4876793fac8a006aad0a62 inherit pub_methods_classsigc_1_1mem__functor4"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor4.html#aef140dac7b4876793fac8a006aad0a62">More...</a><br /></td></tr>
+<tr class="separator:aef140dac7b4876793fac8a006aad0a62 inherit pub_methods_classsigc_1_1mem__functor4"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:aa9a90c28652fb499438e757cdc6f3be7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1limit__reference.html">limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor4.html#aa9a90c28652fb499438e757cdc6f3be7">obj_</a></td></tr>
+<tr class="separator:aa9a90c28652fb499438e757cdc6f3be7"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1mem__functor4"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1mem__functor4')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1mem__functor4.html">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td></tr>
+<tr class="memitem:a28282d9285ca1a2075fd8041905a6302 inherit pro_attribs_classsigc_1_1mem__functor4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor4.html#a9dcf1ef95187c2588ecf2abb089cc7c8">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor4.html#a28282d9285ca1a2075fd8041905a6302">func_ptr_</a></td></tr>
+<tr class="separator:a28282d9285ca1a2075fd8041905a6302 inherit pro_attribs_classsigc_1_1mem__functor4"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4><br />
+class sigc::bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__mem__functor4.html" title="bound_mem_functor4 encapsulates a method with 4 arguments and an object instance.">bound_mem_functor4</a> encapsulates a method with 4 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__mem__functor4.html" title="bound_mem_functor4 encapsulates a method with 4 arguments and an object instance.">bound_mem_functor4</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__mem__functor4.html#a0a9d2fb52ef15ae8d4e56238217c0539" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__mem__functor4.html#a0a9d2fb52ef15ae8d4e56238217c0539" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__mem__functor4.html#a0a9d2fb52ef15ae8d4e56238217c0539" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__mem__functor4.html#a0a9d2fb52ef15ae8d4e56238217c0539" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__mem__functor4.html#a0a9d2fb52ef15ae8d4e56238217c0539" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="aeddcfc0ce5fe38259608bfc88af37568"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aeddcfc0ce5fe38259608bfc88af37568">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__mem__functor4.html">sigc::bound_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1bound__mem__functor4.html#aeddcfc0ce5fe38259608bfc88af37568">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a15b592122574775dd2c4804617e1e3dd"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a15b592122574775dd2c4804617e1e3dd">◆ </a></span>bound_mem_functor4() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor4.html">sigc::bound_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1bound__mem__functor4.html">bound_mem_functor4</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__mem__functor4.html#aeddcfc0ce5fe38259608bfc88af37568">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__mem__functor4.html" title="bound_mem_functor4 encapsulates a method with 4 arguments and an object instance.">bound_mem_functor4</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000166">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__mem__functor4.html#a0a9d2fb52ef15ae8d4e56238217c0539" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="ae15ccaa9f58865b2cd9929644aa85612"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae15ccaa9f58865b2cd9929644aa85612">◆ </a></span>bound_mem_functor4() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor4.html">sigc::bound_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1bound__mem__functor4.html">bound_mem_functor4</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__mem__functor4.html#aeddcfc0ce5fe38259608bfc88af37568">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__mem__functor4.html" title="bound_mem_functor4 encapsulates a method with 4 arguments and an object instance.">bound_mem_functor4</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__mem__functor4.html#a0a9d2fb52ef15ae8d4e56238217c0539" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a0a9d2fb52ef15ae8d4e56238217c0539"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0a9d2fb52ef15ae8d4e56238217c0539">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__mem__functor4.html">sigc::bound_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="aa9a90c28652fb499438e757cdc6f3be7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa9a90c28652fb499438e757cdc6f3be7">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1limit__reference.html">limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__mem__functor4.html">sigc::bound_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >" name="sigc::bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >">
+<area shape="rect" id="node1" title="bound_mem_functor4 encapsulates a method with 4 arguments and an object instance." alt="" coords="5,199,204,255"/>
+<area shape="rect" id="node2" href="$classsigc_1_1mem__functor4.html" title="mem_functor4 wraps methods with 4 argument(s)." alt="" coords="21,80,188,151"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="35,5,175,32"/>
+</map>
--- /dev/null
+eb22badb0b56f8bc33151c82294f55c0
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__mem__functor5.html">bound_mem_functor5</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__mem__functor5.html">sigc::bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor5.html#aaf05ba83268cf4a55f96db281898b406">bound_mem_functor5</a>(T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor5.html">sigc::bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor5.html#a179304173879dac0023d49e313125c8c">bound_mem_functor5</a>(T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor5.html">sigc::bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor5.html#a73a58b713dccc6a48b0083063b0df719">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1mem__functor5.html">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor5.html#a91181f20bd393befce307655486949ad">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor5.html">sigc::bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor5.html#a9048a4a2216e20f9f34380020f5b67ec">mem_functor5</a>()</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor5.html">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor5.html#a01bdff47bf4aed8c52fdfd5520fdf3cf">mem_functor5</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor5.html">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor5.html#a477578c56471258d6eaefb45713dbae8">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor5.html">sigc::bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor5.html#aa1de6366cd9e5f0ea037287438a8072f">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor5.html">sigc::bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor5.html#a7ad7a4d81470125047755dfa8509c6dc">sigc::mem_functor5::operator()</a>(T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor5.html">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor5.html#af1ce121edd0248d104f95e239af683bd">sigc::mem_functor5::operator()</a>(T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor5.html">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor5.html#a3e0587ce338328d42f44c4e5f79be6ed">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor5.html">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__mem__functor5.html">bound_mem_functor5</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__mem__functor5-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__mem__functor5.html" title="bound_mem_functor5 encapsulates a method with 5 arguments and an object instance.">bound_mem_functor5</a> encapsulates a method with 5 arguments and an object instance.
+ <a href="classsigc_1_1bound__mem__functor5.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__mem__functor5__inherit__graph.png" border="0" usemap="#asigc_1_1bound__mem__functor5_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__mem__functor5_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_01_4_inherit__map" id="asigc_1_1bound__mem__functor5_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_01_4_inherit__map">
+<area shape="rect" title="bound_mem_functor5 encapsulates a method with 5 arguments and an object instance." alt="" coords="5,199,204,269"/>
+<area shape="rect" href="classsigc_1_1mem__functor5.html" title="mem_functor5 wraps methods with 5 argument(s)." alt="" coords="21,80,188,151"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="35,5,175,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a91181f20bd393befce307655486949ad"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor5.html#a91181f20bd393befce307655486949ad">function_type</a></td></tr>
+<tr class="separator:a91181f20bd393befce307655486949ad"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1mem__functor5"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1mem__functor5')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1mem__functor5.html">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td></tr>
+<tr class="memitem:a66e9bb0c9829b13af029ee2127b54eb5 inherit pub_types_classsigc_1_1mem__functor5"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor5.html#a66e9bb0c9829b13af029ee2127b54eb5">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)</td></tr>
+<tr class="separator:a66e9bb0c9829b13af029ee2127b54eb5 inherit pub_types_classsigc_1_1mem__functor5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3e0587ce338328d42f44c4e5f79be6ed inherit pub_types_classsigc_1_1mem__functor5"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor5.html#a3e0587ce338328d42f44c4e5f79be6ed">result_type</a></td></tr>
+<tr class="separator:a3e0587ce338328d42f44c4e5f79be6ed inherit pub_types_classsigc_1_1mem__functor5"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a179304173879dac0023d49e313125c8c"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor5.html#a179304173879dac0023d49e313125c8c">bound_mem_functor5</a> (T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__mem__functor5.html#a91181f20bd393befce307655486949ad">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a179304173879dac0023d49e313125c8c"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__mem__functor5.html" title="bound_mem_functor5 encapsulates a method with 5 arguments and an object instance.">bound_mem_functor5</a> object that wraps the passed method. <a href="classsigc_1_1bound__mem__functor5.html#a179304173879dac0023d49e313125c8c">More...</a><br /></td></tr>
+<tr class="separator:a179304173879dac0023d49e313125c8c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aaf05ba83268cf4a55f96db281898b406"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor5.html#aaf05ba83268cf4a55f96db281898b406">bound_mem_functor5</a> (T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__mem__functor5.html#a91181f20bd393befce307655486949ad">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:aaf05ba83268cf4a55f96db281898b406"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__mem__functor5.html" title="bound_mem_functor5 encapsulates a method with 5 arguments and an object instance.">bound_mem_functor5</a> object that wraps the passed method. <a href="classsigc_1_1bound__mem__functor5.html#aaf05ba83268cf4a55f96db281898b406">More...</a><br /></td></tr>
+<tr class="separator:aaf05ba83268cf4a55f96db281898b406"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa1de6366cd9e5f0ea037287438a8072f"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor5.html#aa1de6366cd9e5f0ea037287438a8072f">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:aa1de6366cd9e5f0ea037287438a8072f"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__mem__functor5.html#aa1de6366cd9e5f0ea037287438a8072f">More...</a><br /></td></tr>
+<tr class="separator:aa1de6366cd9e5f0ea037287438a8072f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1mem__functor5"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1mem__functor5')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1mem__functor5.html">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td></tr>
+<tr class="memitem:a9048a4a2216e20f9f34380020f5b67ec inherit pub_methods_classsigc_1_1mem__functor5"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor5.html#a9048a4a2216e20f9f34380020f5b67ec">mem_functor5</a> ()</td></tr>
+<tr class="memdesc:a9048a4a2216e20f9f34380020f5b67ec inherit pub_methods_classsigc_1_1mem__functor5"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1mem__functor5.html#a9048a4a2216e20f9f34380020f5b67ec">More...</a><br /></td></tr>
+<tr class="separator:a9048a4a2216e20f9f34380020f5b67ec inherit pub_methods_classsigc_1_1mem__functor5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a01bdff47bf4aed8c52fdfd5520fdf3cf inherit pub_methods_classsigc_1_1mem__functor5"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor5.html#a01bdff47bf4aed8c52fdfd5520fdf3cf">mem_functor5</a> (<a class="el" href="classsigc_1_1mem__functor5.html#a66e9bb0c9829b13af029ee2127b54eb5">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a01bdff47bf4aed8c52fdfd5520fdf3cf inherit pub_methods_classsigc_1_1mem__functor5"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1mem__functor5.html" title="mem_functor5 wraps methods with 5 argument(s).">mem_functor5</a> object that wraps the passed method. <a href="classsigc_1_1mem__functor5.html#a01bdff47bf4aed8c52fdfd5520fdf3cf">More...</a><br /></td></tr>
+<tr class="separator:a01bdff47bf4aed8c52fdfd5520fdf3cf inherit pub_methods_classsigc_1_1mem__functor5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af1ce121edd0248d104f95e239af683bd inherit pub_methods_classsigc_1_1mem__functor5"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor5.html#af1ce121edd0248d104f95e239af683bd">operator()</a> (T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:af1ce121edd0248d104f95e239af683bd inherit pub_methods_classsigc_1_1mem__functor5"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor5.html#af1ce121edd0248d104f95e239af683bd">More...</a><br /></td></tr>
+<tr class="separator:af1ce121edd0248d104f95e239af683bd inherit pub_methods_classsigc_1_1mem__functor5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7ad7a4d81470125047755dfa8509c6dc inherit pub_methods_classsigc_1_1mem__functor5"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor5.html#a7ad7a4d81470125047755dfa8509c6dc">operator()</a> (T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:a7ad7a4d81470125047755dfa8509c6dc inherit pub_methods_classsigc_1_1mem__functor5"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor5.html#a7ad7a4d81470125047755dfa8509c6dc">More...</a><br /></td></tr>
+<tr class="separator:a7ad7a4d81470125047755dfa8509c6dc inherit pub_methods_classsigc_1_1mem__functor5"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:a477578c56471258d6eaefb45713dbae8"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1limit__reference.html">limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor5.html#a477578c56471258d6eaefb45713dbae8">obj_</a></td></tr>
+<tr class="separator:a477578c56471258d6eaefb45713dbae8"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1mem__functor5"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1mem__functor5')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1mem__functor5.html">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td></tr>
+<tr class="memitem:a73a58b713dccc6a48b0083063b0df719 inherit pro_attribs_classsigc_1_1mem__functor5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor5.html#a66e9bb0c9829b13af029ee2127b54eb5">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor5.html#a73a58b713dccc6a48b0083063b0df719">func_ptr_</a></td></tr>
+<tr class="separator:a73a58b713dccc6a48b0083063b0df719 inherit pro_attribs_classsigc_1_1mem__functor5"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5><br />
+class sigc::bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__mem__functor5.html" title="bound_mem_functor5 encapsulates a method with 5 arguments and an object instance.">bound_mem_functor5</a> encapsulates a method with 5 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__mem__functor5.html" title="bound_mem_functor5 encapsulates a method with 5 arguments and an object instance.">bound_mem_functor5</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__mem__functor5.html#aa1de6366cd9e5f0ea037287438a8072f" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__mem__functor5.html#aa1de6366cd9e5f0ea037287438a8072f" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__mem__functor5.html#aa1de6366cd9e5f0ea037287438a8072f" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__mem__functor5.html#aa1de6366cd9e5f0ea037287438a8072f" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__mem__functor5.html#aa1de6366cd9e5f0ea037287438a8072f" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__mem__functor5.html#aa1de6366cd9e5f0ea037287438a8072f" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a91181f20bd393befce307655486949ad"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a91181f20bd393befce307655486949ad">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__mem__functor5.html">sigc::bound_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1bound__mem__functor5.html#a91181f20bd393befce307655486949ad">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="aaf05ba83268cf4a55f96db281898b406"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aaf05ba83268cf4a55f96db281898b406">◆ </a></span>bound_mem_functor5() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor5.html">sigc::bound_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1bound__mem__functor5.html">bound_mem_functor5</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__mem__functor5.html#a91181f20bd393befce307655486949ad">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__mem__functor5.html" title="bound_mem_functor5 encapsulates a method with 5 arguments and an object instance.">bound_mem_functor5</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000167">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__mem__functor5.html#aa1de6366cd9e5f0ea037287438a8072f" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a179304173879dac0023d49e313125c8c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a179304173879dac0023d49e313125c8c">◆ </a></span>bound_mem_functor5() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor5.html">sigc::bound_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1bound__mem__functor5.html">bound_mem_functor5</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__mem__functor5.html#a91181f20bd393befce307655486949ad">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__mem__functor5.html" title="bound_mem_functor5 encapsulates a method with 5 arguments and an object instance.">bound_mem_functor5</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__mem__functor5.html#aa1de6366cd9e5f0ea037287438a8072f" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="aa1de6366cd9e5f0ea037287438a8072f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa1de6366cd9e5f0ea037287438a8072f">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__mem__functor5.html">sigc::bound_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a477578c56471258d6eaefb45713dbae8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a477578c56471258d6eaefb45713dbae8">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1limit__reference.html">limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__mem__functor5.html">sigc::bound_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >" name="sigc::bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >">
+<area shape="rect" id="node1" title="bound_mem_functor5 encapsulates a method with 5 arguments and an object instance." alt="" coords="5,199,204,269"/>
+<area shape="rect" id="node2" href="$classsigc_1_1mem__functor5.html" title="mem_functor5 wraps methods with 5 argument(s)." alt="" coords="21,80,188,151"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="35,5,175,32"/>
+</map>
--- /dev/null
+2f4fd456254fe8f55ad94482a4b24321
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__mem__functor6.html">bound_mem_functor6</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__mem__functor6.html">sigc::bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor6.html#ab2724a290ceef4f2c279156b606e8c88">bound_mem_functor6</a>(T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor6.html">sigc::bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor6.html#abff60fd63e92b1c28c2aacf1cee93508">bound_mem_functor6</a>(T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor6.html">sigc::bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor6.html#af07a44f7435cf15228903b0868fac956">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1mem__functor6.html">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor6.html#ac92e6b87056623eeec0d09a35f41296d">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor6.html">sigc::bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor6.html#aaa43195f4b4e39c76c10478539d35172">mem_functor6</a>()</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor6.html">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor6.html#aabc6bb723e0831e27a0a9131525d96bc">mem_functor6</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor6.html">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor6.html#a8aced07018e8f32dcc4339ce26a0e924">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor6.html">sigc::bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor6.html#ad44376814c73959398026d4e0df3d401">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor6.html">sigc::bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor6.html#afc40dbe8ea11726018dfa7c1ca435f3d">sigc::mem_functor6::operator()</a>(T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor6.html">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor6.html#a4a322216c1783eb8ad7f63972b3a1164">sigc::mem_functor6::operator()</a>(T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor6.html">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor6.html#af80425ff57ca2115cba771c275f49e36">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor6.html">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__mem__functor6.html">bound_mem_functor6</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__mem__functor6-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__mem__functor6.html" title="bound_mem_functor6 encapsulates a method with 6 arguments and an object instance.">bound_mem_functor6</a> encapsulates a method with 6 arguments and an object instance.
+ <a href="classsigc_1_1bound__mem__functor6.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__mem__functor6__inherit__graph.png" border="0" usemap="#asigc_1_1bound__mem__functor6_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__mem__functor6_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_01_4_inherit__map" id="asigc_1_1bound__mem__functor6_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_01_4_inherit__map">
+<area shape="rect" title="bound_mem_functor6 encapsulates a method with 6 arguments and an object instance." alt="" coords="431,5,629,76"/>
+<area shape="rect" href="classsigc_1_1mem__functor6.html" title="mem_functor6 wraps methods with 6 argument(s)." alt="" coords="193,5,383,76"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,27,145,54"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:ac92e6b87056623eeec0d09a35f41296d"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor6.html#ac92e6b87056623eeec0d09a35f41296d">function_type</a></td></tr>
+<tr class="separator:ac92e6b87056623eeec0d09a35f41296d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1mem__functor6"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1mem__functor6')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1mem__functor6.html">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td></tr>
+<tr class="memitem:a202287b72f6213f64a696b185fb90268 inherit pub_types_classsigc_1_1mem__functor6"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor6.html#a202287b72f6213f64a696b185fb90268">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)</td></tr>
+<tr class="separator:a202287b72f6213f64a696b185fb90268 inherit pub_types_classsigc_1_1mem__functor6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af80425ff57ca2115cba771c275f49e36 inherit pub_types_classsigc_1_1mem__functor6"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor6.html#af80425ff57ca2115cba771c275f49e36">result_type</a></td></tr>
+<tr class="separator:af80425ff57ca2115cba771c275f49e36 inherit pub_types_classsigc_1_1mem__functor6"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:abff60fd63e92b1c28c2aacf1cee93508"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor6.html#abff60fd63e92b1c28c2aacf1cee93508">bound_mem_functor6</a> (T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__mem__functor6.html#ac92e6b87056623eeec0d09a35f41296d">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:abff60fd63e92b1c28c2aacf1cee93508"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__mem__functor6.html" title="bound_mem_functor6 encapsulates a method with 6 arguments and an object instance.">bound_mem_functor6</a> object that wraps the passed method. <a href="classsigc_1_1bound__mem__functor6.html#abff60fd63e92b1c28c2aacf1cee93508">More...</a><br /></td></tr>
+<tr class="separator:abff60fd63e92b1c28c2aacf1cee93508"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab2724a290ceef4f2c279156b606e8c88"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor6.html#ab2724a290ceef4f2c279156b606e8c88">bound_mem_functor6</a> (T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__mem__functor6.html#ac92e6b87056623eeec0d09a35f41296d">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:ab2724a290ceef4f2c279156b606e8c88"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__mem__functor6.html" title="bound_mem_functor6 encapsulates a method with 6 arguments and an object instance.">bound_mem_functor6</a> object that wraps the passed method. <a href="classsigc_1_1bound__mem__functor6.html#ab2724a290ceef4f2c279156b606e8c88">More...</a><br /></td></tr>
+<tr class="separator:ab2724a290ceef4f2c279156b606e8c88"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad44376814c73959398026d4e0df3d401"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor6.html#ad44376814c73959398026d4e0df3d401">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:ad44376814c73959398026d4e0df3d401"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__mem__functor6.html#ad44376814c73959398026d4e0df3d401">More...</a><br /></td></tr>
+<tr class="separator:ad44376814c73959398026d4e0df3d401"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1mem__functor6"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1mem__functor6')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1mem__functor6.html">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td></tr>
+<tr class="memitem:aaa43195f4b4e39c76c10478539d35172 inherit pub_methods_classsigc_1_1mem__functor6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor6.html#aaa43195f4b4e39c76c10478539d35172">mem_functor6</a> ()</td></tr>
+<tr class="memdesc:aaa43195f4b4e39c76c10478539d35172 inherit pub_methods_classsigc_1_1mem__functor6"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1mem__functor6.html#aaa43195f4b4e39c76c10478539d35172">More...</a><br /></td></tr>
+<tr class="separator:aaa43195f4b4e39c76c10478539d35172 inherit pub_methods_classsigc_1_1mem__functor6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aabc6bb723e0831e27a0a9131525d96bc inherit pub_methods_classsigc_1_1mem__functor6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor6.html#aabc6bb723e0831e27a0a9131525d96bc">mem_functor6</a> (<a class="el" href="classsigc_1_1mem__functor6.html#a202287b72f6213f64a696b185fb90268">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:aabc6bb723e0831e27a0a9131525d96bc inherit pub_methods_classsigc_1_1mem__functor6"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1mem__functor6.html" title="mem_functor6 wraps methods with 6 argument(s).">mem_functor6</a> object that wraps the passed method. <a href="classsigc_1_1mem__functor6.html#aabc6bb723e0831e27a0a9131525d96bc">More...</a><br /></td></tr>
+<tr class="separator:aabc6bb723e0831e27a0a9131525d96bc inherit pub_methods_classsigc_1_1mem__functor6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4a322216c1783eb8ad7f63972b3a1164 inherit pub_methods_classsigc_1_1mem__functor6"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor6.html#a4a322216c1783eb8ad7f63972b3a1164">operator()</a> (T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:a4a322216c1783eb8ad7f63972b3a1164 inherit pub_methods_classsigc_1_1mem__functor6"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor6.html#a4a322216c1783eb8ad7f63972b3a1164">More...</a><br /></td></tr>
+<tr class="separator:a4a322216c1783eb8ad7f63972b3a1164 inherit pub_methods_classsigc_1_1mem__functor6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afc40dbe8ea11726018dfa7c1ca435f3d inherit pub_methods_classsigc_1_1mem__functor6"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor6.html#afc40dbe8ea11726018dfa7c1ca435f3d">operator()</a> (T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:afc40dbe8ea11726018dfa7c1ca435f3d inherit pub_methods_classsigc_1_1mem__functor6"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor6.html#afc40dbe8ea11726018dfa7c1ca435f3d">More...</a><br /></td></tr>
+<tr class="separator:afc40dbe8ea11726018dfa7c1ca435f3d inherit pub_methods_classsigc_1_1mem__functor6"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:a8aced07018e8f32dcc4339ce26a0e924"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1limit__reference.html">limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor6.html#a8aced07018e8f32dcc4339ce26a0e924">obj_</a></td></tr>
+<tr class="separator:a8aced07018e8f32dcc4339ce26a0e924"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1mem__functor6"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1mem__functor6')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1mem__functor6.html">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td></tr>
+<tr class="memitem:af07a44f7435cf15228903b0868fac956 inherit pro_attribs_classsigc_1_1mem__functor6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor6.html#a202287b72f6213f64a696b185fb90268">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor6.html#af07a44f7435cf15228903b0868fac956">func_ptr_</a></td></tr>
+<tr class="separator:af07a44f7435cf15228903b0868fac956 inherit pro_attribs_classsigc_1_1mem__functor6"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6><br />
+class sigc::bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__mem__functor6.html" title="bound_mem_functor6 encapsulates a method with 6 arguments and an object instance.">bound_mem_functor6</a> encapsulates a method with 6 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__mem__functor6.html" title="bound_mem_functor6 encapsulates a method with 6 arguments and an object instance.">bound_mem_functor6</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__mem__functor6.html#ad44376814c73959398026d4e0df3d401" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__mem__functor6.html#ad44376814c73959398026d4e0df3d401" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__mem__functor6.html#ad44376814c73959398026d4e0df3d401" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__mem__functor6.html#ad44376814c73959398026d4e0df3d401" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__mem__functor6.html#ad44376814c73959398026d4e0df3d401" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg6</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__mem__functor6.html#ad44376814c73959398026d4e0df3d401" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__mem__functor6.html#ad44376814c73959398026d4e0df3d401" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="ac92e6b87056623eeec0d09a35f41296d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac92e6b87056623eeec0d09a35f41296d">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__mem__functor6.html">sigc::bound_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1bound__mem__functor6.html#ac92e6b87056623eeec0d09a35f41296d">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="ab2724a290ceef4f2c279156b606e8c88"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab2724a290ceef4f2c279156b606e8c88">◆ </a></span>bound_mem_functor6() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor6.html">sigc::bound_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1bound__mem__functor6.html">bound_mem_functor6</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__mem__functor6.html#ac92e6b87056623eeec0d09a35f41296d">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__mem__functor6.html" title="bound_mem_functor6 encapsulates a method with 6 arguments and an object instance.">bound_mem_functor6</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000168">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__mem__functor6.html#ad44376814c73959398026d4e0df3d401" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="abff60fd63e92b1c28c2aacf1cee93508"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abff60fd63e92b1c28c2aacf1cee93508">◆ </a></span>bound_mem_functor6() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor6.html">sigc::bound_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1bound__mem__functor6.html">bound_mem_functor6</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__mem__functor6.html#ac92e6b87056623eeec0d09a35f41296d">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__mem__functor6.html" title="bound_mem_functor6 encapsulates a method with 6 arguments and an object instance.">bound_mem_functor6</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__mem__functor6.html#ad44376814c73959398026d4e0df3d401" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="ad44376814c73959398026d4e0df3d401"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad44376814c73959398026d4e0df3d401">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__mem__functor6.html">sigc::bound_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a8aced07018e8f32dcc4339ce26a0e924"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8aced07018e8f32dcc4339ce26a0e924">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1limit__reference.html">limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__mem__functor6.html">sigc::bound_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >" name="sigc::bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >">
+<area shape="rect" id="node1" title="bound_mem_functor6 encapsulates a method with 6 arguments and an object instance." alt="" coords="431,5,629,76"/>
+<area shape="rect" id="node2" href="$classsigc_1_1mem__functor6.html" title="mem_functor6 wraps methods with 6 argument(s)." alt="" coords="193,5,383,76"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,27,145,54"/>
+</map>
--- /dev/null
+877c2d82fb93215e8b3ad735ac1172fd
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__mem__functor7.html">bound_mem_functor7</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__mem__functor7.html">sigc::bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor7.html#a989011ff72d908959d2f0ad346357706">bound_mem_functor7</a>(T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor7.html">sigc::bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor7.html#a29f43e3ad8d4714c8f3477be02d62c3d">bound_mem_functor7</a>(T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor7.html">sigc::bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor7.html#a779c41d697c3b80d08a06cbcc9a5ea25">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1mem__functor7.html">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor7.html#a0fcd4636185a806d055d6b885503863b">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor7.html">sigc::bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor7.html#afbb9b8ecaa25e0dd85c0f3d539f198b4">mem_functor7</a>()</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor7.html">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor7.html#a79de1ccebb568e82b7f7a67ab85e4dc6">mem_functor7</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor7.html">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor7.html#a03e799b2af9cdc19c76e81d0bcb843ad">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor7.html">sigc::bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor7.html#ab0c379b445a5655f55f8260c699e7053">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1bound__mem__functor7.html">sigc::bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor7.html#ab95293e358caf96b5dbf123f024eed8d">sigc::mem_functor7::operator()</a>(T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor7.html">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor7.html#ad8e9031dc12742265d834a5529b1f00d">sigc::mem_functor7::operator()</a>(T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor7.html">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor7.html#a967b5f6572e988ea0833818b993745f9">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor7.html">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__mem__functor7.html">bound_mem_functor7</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__mem__functor7-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__mem__functor7.html" title="bound_mem_functor7 encapsulates a method with 7 arguments and an object instance.">bound_mem_functor7</a> encapsulates a method with 7 arguments and an object instance.
+ <a href="classsigc_1_1bound__mem__functor7.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__mem__functor7__inherit__graph.png" border="0" usemap="#asigc_1_1bound__mem__functor7_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__mem__functor7_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map" id="asigc_1_1bound__mem__functor7_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map">
+<area shape="rect" title="bound_mem_functor7 encapsulates a method with 7 arguments and an object instance." alt="" coords="420,13,619,83"/>
+<area shape="rect" href="classsigc_1_1mem__functor7.html" title="mem_functor7 wraps methods with 7 argument(s)." alt="" coords="193,5,372,91"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,35,145,61"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a0fcd4636185a806d055d6b885503863b"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor7.html#a0fcd4636185a806d055d6b885503863b">function_type</a></td></tr>
+<tr class="separator:a0fcd4636185a806d055d6b885503863b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1mem__functor7"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1mem__functor7')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1mem__functor7.html">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td></tr>
+<tr class="memitem:a408f0afec5b4c750ca8e1bdab0f8b535 inherit pub_types_classsigc_1_1mem__functor7"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor7.html#a408f0afec5b4c750ca8e1bdab0f8b535">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)</td></tr>
+<tr class="separator:a408f0afec5b4c750ca8e1bdab0f8b535 inherit pub_types_classsigc_1_1mem__functor7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a967b5f6572e988ea0833818b993745f9 inherit pub_types_classsigc_1_1mem__functor7"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor7.html#a967b5f6572e988ea0833818b993745f9">result_type</a></td></tr>
+<tr class="separator:a967b5f6572e988ea0833818b993745f9 inherit pub_types_classsigc_1_1mem__functor7"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a29f43e3ad8d4714c8f3477be02d62c3d"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor7.html#a29f43e3ad8d4714c8f3477be02d62c3d">bound_mem_functor7</a> (T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__mem__functor7.html#a0fcd4636185a806d055d6b885503863b">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a29f43e3ad8d4714c8f3477be02d62c3d"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__mem__functor7.html" title="bound_mem_functor7 encapsulates a method with 7 arguments and an object instance.">bound_mem_functor7</a> object that wraps the passed method. <a href="classsigc_1_1bound__mem__functor7.html#a29f43e3ad8d4714c8f3477be02d62c3d">More...</a><br /></td></tr>
+<tr class="separator:a29f43e3ad8d4714c8f3477be02d62c3d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a989011ff72d908959d2f0ad346357706"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor7.html#a989011ff72d908959d2f0ad346357706">bound_mem_functor7</a> (T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__mem__functor7.html#a0fcd4636185a806d055d6b885503863b">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a989011ff72d908959d2f0ad346357706"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__mem__functor7.html" title="bound_mem_functor7 encapsulates a method with 7 arguments and an object instance.">bound_mem_functor7</a> object that wraps the passed method. <a href="classsigc_1_1bound__mem__functor7.html#a989011ff72d908959d2f0ad346357706">More...</a><br /></td></tr>
+<tr class="separator:a989011ff72d908959d2f0ad346357706"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0c379b445a5655f55f8260c699e7053"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor7.html#ab0c379b445a5655f55f8260c699e7053">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:ab0c379b445a5655f55f8260c699e7053"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__mem__functor7.html#ab0c379b445a5655f55f8260c699e7053">More...</a><br /></td></tr>
+<tr class="separator:ab0c379b445a5655f55f8260c699e7053"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1mem__functor7"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1mem__functor7')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1mem__functor7.html">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td></tr>
+<tr class="memitem:afbb9b8ecaa25e0dd85c0f3d539f198b4 inherit pub_methods_classsigc_1_1mem__functor7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor7.html#afbb9b8ecaa25e0dd85c0f3d539f198b4">mem_functor7</a> ()</td></tr>
+<tr class="memdesc:afbb9b8ecaa25e0dd85c0f3d539f198b4 inherit pub_methods_classsigc_1_1mem__functor7"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1mem__functor7.html#afbb9b8ecaa25e0dd85c0f3d539f198b4">More...</a><br /></td></tr>
+<tr class="separator:afbb9b8ecaa25e0dd85c0f3d539f198b4 inherit pub_methods_classsigc_1_1mem__functor7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a79de1ccebb568e82b7f7a67ab85e4dc6 inherit pub_methods_classsigc_1_1mem__functor7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor7.html#a79de1ccebb568e82b7f7a67ab85e4dc6">mem_functor7</a> (<a class="el" href="classsigc_1_1mem__functor7.html#a408f0afec5b4c750ca8e1bdab0f8b535">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a79de1ccebb568e82b7f7a67ab85e4dc6 inherit pub_methods_classsigc_1_1mem__functor7"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1mem__functor7.html" title="mem_functor7 wraps methods with 7 argument(s).">mem_functor7</a> object that wraps the passed method. <a href="classsigc_1_1mem__functor7.html#a79de1ccebb568e82b7f7a67ab85e4dc6">More...</a><br /></td></tr>
+<tr class="separator:a79de1ccebb568e82b7f7a67ab85e4dc6 inherit pub_methods_classsigc_1_1mem__functor7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad8e9031dc12742265d834a5529b1f00d inherit pub_methods_classsigc_1_1mem__functor7"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor7.html#ad8e9031dc12742265d834a5529b1f00d">operator()</a> (T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:ad8e9031dc12742265d834a5529b1f00d inherit pub_methods_classsigc_1_1mem__functor7"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor7.html#ad8e9031dc12742265d834a5529b1f00d">More...</a><br /></td></tr>
+<tr class="separator:ad8e9031dc12742265d834a5529b1f00d inherit pub_methods_classsigc_1_1mem__functor7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab95293e358caf96b5dbf123f024eed8d inherit pub_methods_classsigc_1_1mem__functor7"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor7.html#ab95293e358caf96b5dbf123f024eed8d">operator()</a> (T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:ab95293e358caf96b5dbf123f024eed8d inherit pub_methods_classsigc_1_1mem__functor7"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor7.html#ab95293e358caf96b5dbf123f024eed8d">More...</a><br /></td></tr>
+<tr class="separator:ab95293e358caf96b5dbf123f024eed8d inherit pub_methods_classsigc_1_1mem__functor7"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:a03e799b2af9cdc19c76e81d0bcb843ad"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1limit__reference.html">limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor7.html#a03e799b2af9cdc19c76e81d0bcb843ad">obj_</a></td></tr>
+<tr class="separator:a03e799b2af9cdc19c76e81d0bcb843ad"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1mem__functor7"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1mem__functor7')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1mem__functor7.html">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td></tr>
+<tr class="memitem:a779c41d697c3b80d08a06cbcc9a5ea25 inherit pro_attribs_classsigc_1_1mem__functor7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor7.html#a408f0afec5b4c750ca8e1bdab0f8b535">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor7.html#a779c41d697c3b80d08a06cbcc9a5ea25">func_ptr_</a></td></tr>
+<tr class="separator:a779c41d697c3b80d08a06cbcc9a5ea25 inherit pro_attribs_classsigc_1_1mem__functor7"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7><br />
+class sigc::bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__mem__functor7.html" title="bound_mem_functor7 encapsulates a method with 7 arguments and an object instance.">bound_mem_functor7</a> encapsulates a method with 7 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__mem__functor7.html" title="bound_mem_functor7 encapsulates a method with 7 arguments and an object instance.">bound_mem_functor7</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__mem__functor7.html#ab0c379b445a5655f55f8260c699e7053" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__mem__functor7.html#ab0c379b445a5655f55f8260c699e7053" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__mem__functor7.html#ab0c379b445a5655f55f8260c699e7053" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__mem__functor7.html#ab0c379b445a5655f55f8260c699e7053" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__mem__functor7.html#ab0c379b445a5655f55f8260c699e7053" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg6</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__mem__functor7.html#ab0c379b445a5655f55f8260c699e7053" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg7</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__mem__functor7.html#ab0c379b445a5655f55f8260c699e7053" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__mem__functor7.html#ab0c379b445a5655f55f8260c699e7053" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a0fcd4636185a806d055d6b885503863b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0fcd4636185a806d055d6b885503863b">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__mem__functor7.html">sigc::bound_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1bound__mem__functor7.html#a0fcd4636185a806d055d6b885503863b">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a989011ff72d908959d2f0ad346357706"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a989011ff72d908959d2f0ad346357706">◆ </a></span>bound_mem_functor7() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor7.html">sigc::bound_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1bound__mem__functor7.html">bound_mem_functor7</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__mem__functor7.html#a0fcd4636185a806d055d6b885503863b">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__mem__functor7.html" title="bound_mem_functor7 encapsulates a method with 7 arguments and an object instance.">bound_mem_functor7</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000169">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__mem__functor7.html#ab0c379b445a5655f55f8260c699e7053" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a29f43e3ad8d4714c8f3477be02d62c3d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a29f43e3ad8d4714c8f3477be02d62c3d">◆ </a></span>bound_mem_functor7() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor7.html">sigc::bound_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1bound__mem__functor7.html">bound_mem_functor7</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__mem__functor7.html#a0fcd4636185a806d055d6b885503863b">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__mem__functor7.html" title="bound_mem_functor7 encapsulates a method with 7 arguments and an object instance.">bound_mem_functor7</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__mem__functor7.html#ab0c379b445a5655f55f8260c699e7053" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="ab0c379b445a5655f55f8260c699e7053"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab0c379b445a5655f55f8260c699e7053">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__mem__functor7.html">sigc::bound_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > </td>
+ <td class="paramname"><em>_A_a7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a7</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a03e799b2af9cdc19c76e81d0bcb843ad"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a03e799b2af9cdc19c76e81d0bcb843ad">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1limit__reference.html">limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__mem__functor7.html">sigc::bound_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >" name="sigc::bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >">
+<area shape="rect" id="node1" title="bound_mem_functor7 encapsulates a method with 7 arguments and an object instance." alt="" coords="420,13,619,83"/>
+<area shape="rect" id="node2" href="$classsigc_1_1mem__functor7.html" title="mem_functor7 wraps methods with 7 argument(s)." alt="" coords="193,5,372,91"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,35,145,61"/>
+</map>
--- /dev/null
+cde37fcdd810da947bfcdbd36fb685ae
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">bound_volatile_mem_functor0</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_volatile_mem_functor0< T_return, T_obj > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">sigc::bound_volatile_mem_functor0< T_return, T_obj ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html#a5812d3638dc20b9fe37688d31dde8ed8">bound_volatile_mem_functor0</a>(T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">sigc::bound_volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html#a4f81dd585b0aae830cd585ebb5867e20">bound_volatile_mem_functor0</a>(T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">sigc::bound_volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#a874e91ca403b95bb085ed596257de3ec">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor0.html">sigc::volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html#a9a07aa91b2bd5ef0c4fc1a89bad5d3b0">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">sigc::bound_volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html#abc4357df8d4458326135e23965ba5871">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">sigc::bound_volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html#a5726bcc0d34cff2356976bc586d36b44">operator()</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">sigc::bound_volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#af627ef410fac7ec5d2ee842d8f89fe51">sigc::volatile_mem_functor0::operator()</a>(T_obj * _A_obj) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor0.html">sigc::volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#aa5df40ec8fb385594c673a07f3ff8044">sigc::volatile_mem_functor0::operator()</a>(T_obj & _A_obj) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor0.html">sigc::volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#a41fbd67d6bbde0818b880f08f6295396">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor0.html">sigc::volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#ae29bbe3e668b370d2788631465daa63c">volatile_mem_functor0</a>()</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor0.html">sigc::volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#aa4e5e279480d50940eb4b73b9c61b938">volatile_mem_functor0</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor0.html">sigc::volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_volatile_mem_functor0< T_return, T_obj > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">bound_volatile_mem_functor0</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__volatile__mem__functor0-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_volatile_mem_functor0< T_return, T_obj > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html" title="bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance.">bound_volatile_mem_functor0</a> encapsulates a volatile method with 0 arguments and an object instance.
+ <a href="classsigc_1_1bound__volatile__mem__functor0.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_volatile_mem_functor0< T_return, T_obj >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__volatile__mem__functor0__inherit__graph.png" border="0" usemap="#asigc_1_1bound__volatile__mem__functor0_3_01T__return_00_01T__obj_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__volatile__mem__functor0_3_01T__return_00_01T__obj_01_4_inherit__map" id="asigc_1_1bound__volatile__mem__functor0_3_01T__return_00_01T__obj_01_4_inherit__map">
+<area shape="rect" title="bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance." alt="" coords="5,184,203,240"/>
+<area shape="rect" href="classsigc_1_1volatile__mem__functor0.html" title="volatile_mem_functor0 wraps volatile methods with 0 argument(s)." alt="" coords="26,80,182,136"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a9a07aa91b2bd5ef0c4fc1a89bad5d3b0"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html#a9a07aa91b2bd5ef0c4fc1a89bad5d3b0">function_type</a></td></tr>
+<tr class="separator:a9a07aa91b2bd5ef0c4fc1a89bad5d3b0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1volatile__mem__functor0"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1volatile__mem__functor0')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1volatile__mem__functor0.html">sigc::volatile_mem_functor0< T_return, T_obj ></a></td></tr>
+<tr class="memitem:a2f0448d35b580f2b4884292f29b19b2f inherit pub_types_classsigc_1_1volatile__mem__functor0"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#a2f0448d35b580f2b4884292f29b19b2f">function_type</a>) () volatile</td></tr>
+<tr class="separator:a2f0448d35b580f2b4884292f29b19b2f inherit pub_types_classsigc_1_1volatile__mem__functor0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a41fbd67d6bbde0818b880f08f6295396 inherit pub_types_classsigc_1_1volatile__mem__functor0"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#a41fbd67d6bbde0818b880f08f6295396">result_type</a></td></tr>
+<tr class="separator:a41fbd67d6bbde0818b880f08f6295396 inherit pub_types_classsigc_1_1volatile__mem__functor0"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a4f81dd585b0aae830cd585ebb5867e20"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html#a4f81dd585b0aae830cd585ebb5867e20">bound_volatile_mem_functor0</a> (T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html#a9a07aa91b2bd5ef0c4fc1a89bad5d3b0">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a4f81dd585b0aae830cd585ebb5867e20"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html" title="bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance.">bound_volatile_mem_functor0</a> object that wraps the passed method. <a href="classsigc_1_1bound__volatile__mem__functor0.html#a4f81dd585b0aae830cd585ebb5867e20">More...</a><br /></td></tr>
+<tr class="separator:a4f81dd585b0aae830cd585ebb5867e20"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5812d3638dc20b9fe37688d31dde8ed8"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html#a5812d3638dc20b9fe37688d31dde8ed8">bound_volatile_mem_functor0</a> (T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html#a9a07aa91b2bd5ef0c4fc1a89bad5d3b0">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a5812d3638dc20b9fe37688d31dde8ed8"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html" title="bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance.">bound_volatile_mem_functor0</a> object that wraps the passed method. <a href="classsigc_1_1bound__volatile__mem__functor0.html#a5812d3638dc20b9fe37688d31dde8ed8">More...</a><br /></td></tr>
+<tr class="separator:a5812d3638dc20b9fe37688d31dde8ed8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5726bcc0d34cff2356976bc586d36b44"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html#a5726bcc0d34cff2356976bc586d36b44">operator()</a> () const</td></tr>
+<tr class="memdesc:a5726bcc0d34cff2356976bc586d36b44"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__volatile__mem__functor0.html#a5726bcc0d34cff2356976bc586d36b44">More...</a><br /></td></tr>
+<tr class="separator:a5726bcc0d34cff2356976bc586d36b44"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1volatile__mem__functor0"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1volatile__mem__functor0')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1volatile__mem__functor0.html">sigc::volatile_mem_functor0< T_return, T_obj ></a></td></tr>
+<tr class="memitem:ae29bbe3e668b370d2788631465daa63c inherit pub_methods_classsigc_1_1volatile__mem__functor0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#ae29bbe3e668b370d2788631465daa63c">volatile_mem_functor0</a> ()</td></tr>
+<tr class="memdesc:ae29bbe3e668b370d2788631465daa63c inherit pub_methods_classsigc_1_1volatile__mem__functor0"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1volatile__mem__functor0.html#ae29bbe3e668b370d2788631465daa63c">More...</a><br /></td></tr>
+<tr class="separator:ae29bbe3e668b370d2788631465daa63c inherit pub_methods_classsigc_1_1volatile__mem__functor0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa4e5e279480d50940eb4b73b9c61b938 inherit pub_methods_classsigc_1_1volatile__mem__functor0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#aa4e5e279480d50940eb4b73b9c61b938">volatile_mem_functor0</a> (<a class="el" href="classsigc_1_1volatile__mem__functor0.html#a2f0448d35b580f2b4884292f29b19b2f">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:aa4e5e279480d50940eb4b73b9c61b938 inherit pub_methods_classsigc_1_1volatile__mem__functor0"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1volatile__mem__functor0.html" title="volatile_mem_functor0 wraps volatile methods with 0 argument(s).">volatile_mem_functor0</a> object that wraps the passed method. <a href="classsigc_1_1volatile__mem__functor0.html#aa4e5e279480d50940eb4b73b9c61b938">More...</a><br /></td></tr>
+<tr class="separator:aa4e5e279480d50940eb4b73b9c61b938 inherit pub_methods_classsigc_1_1volatile__mem__functor0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa5df40ec8fb385594c673a07f3ff8044 inherit pub_methods_classsigc_1_1volatile__mem__functor0"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#aa5df40ec8fb385594c673a07f3ff8044">operator()</a> (T_obj & _A_obj) const</td></tr>
+<tr class="memdesc:aa5df40ec8fb385594c673a07f3ff8044 inherit pub_methods_classsigc_1_1volatile__mem__functor0"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor0.html#aa5df40ec8fb385594c673a07f3ff8044">More...</a><br /></td></tr>
+<tr class="separator:aa5df40ec8fb385594c673a07f3ff8044 inherit pub_methods_classsigc_1_1volatile__mem__functor0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af627ef410fac7ec5d2ee842d8f89fe51 inherit pub_methods_classsigc_1_1volatile__mem__functor0"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#af627ef410fac7ec5d2ee842d8f89fe51">operator()</a> (T_obj * _A_obj) const</td></tr>
+<tr class="memdesc:af627ef410fac7ec5d2ee842d8f89fe51 inherit pub_methods_classsigc_1_1volatile__mem__functor0"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor0.html#af627ef410fac7ec5d2ee842d8f89fe51">More...</a><br /></td></tr>
+<tr class="separator:af627ef410fac7ec5d2ee842d8f89fe51 inherit pub_methods_classsigc_1_1volatile__mem__functor0"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:abc4357df8d4458326135e23965ba5871"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__limit__reference.html">volatile_limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html#abc4357df8d4458326135e23965ba5871">obj_</a></td></tr>
+<tr class="separator:abc4357df8d4458326135e23965ba5871"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1volatile__mem__functor0"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1volatile__mem__functor0')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1volatile__mem__functor0.html">sigc::volatile_mem_functor0< T_return, T_obj ></a></td></tr>
+<tr class="memitem:a874e91ca403b95bb085ed596257de3ec inherit pro_attribs_classsigc_1_1volatile__mem__functor0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#a2f0448d35b580f2b4884292f29b19b2f">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#a874e91ca403b95bb085ed596257de3ec">func_ptr_</a></td></tr>
+<tr class="separator:a874e91ca403b95bb085ed596257de3ec inherit pro_attribs_classsigc_1_1volatile__mem__functor0"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj><br />
+class sigc::bound_volatile_mem_functor0< T_return, T_obj ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html" title="bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance.">bound_volatile_mem_functor0</a> encapsulates a volatile method with 0 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html" title="bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance.">bound_volatile_mem_functor0</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html#a5726bcc0d34cff2356976bc586d36b44" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a9a07aa91b2bd5ef0c4fc1a89bad5d3b0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9a07aa91b2bd5ef0c4fc1a89bad5d3b0">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">sigc::bound_volatile_mem_functor0</a>< T_return, T_obj >::<a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html#a9a07aa91b2bd5ef0c4fc1a89bad5d3b0">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a5812d3638dc20b9fe37688d31dde8ed8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5812d3638dc20b9fe37688d31dde8ed8">◆ </a></span>bound_volatile_mem_functor0() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">sigc::bound_volatile_mem_functor0</a>< T_return, T_obj >::<a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">bound_volatile_mem_functor0</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html#a9a07aa91b2bd5ef0c4fc1a89bad5d3b0">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html" title="bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance.">bound_volatile_mem_functor0</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000178">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html#a5726bcc0d34cff2356976bc586d36b44" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a4f81dd585b0aae830cd585ebb5867e20"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4f81dd585b0aae830cd585ebb5867e20">◆ </a></span>bound_volatile_mem_functor0() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">sigc::bound_volatile_mem_functor0</a>< T_return, T_obj >::<a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">bound_volatile_mem_functor0</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html#a9a07aa91b2bd5ef0c4fc1a89bad5d3b0">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html" title="bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance.">bound_volatile_mem_functor0</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html#a5726bcc0d34cff2356976bc586d36b44" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a5726bcc0d34cff2356976bc586d36b44"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5726bcc0d34cff2356976bc586d36b44">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">sigc::bound_volatile_mem_functor0</a>< T_return, T_obj >::operator() </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="abc4357df8d4458326135e23965ba5871"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abc4357df8d4458326135e23965ba5871">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__limit__reference.html">volatile_limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">sigc::bound_volatile_mem_functor0</a>< T_return, T_obj >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_volatile_mem_functor0< T_return, T_obj >" name="sigc::bound_volatile_mem_functor0< T_return, T_obj >">
+<area shape="rect" id="node1" title="bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance." alt="" coords="5,184,203,240"/>
+<area shape="rect" id="node2" href="$classsigc_1_1volatile__mem__functor0.html" title="volatile_mem_functor0 wraps volatile methods with 0 argument(s)." alt="" coords="26,80,182,136"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
--- /dev/null
+673ea8039f751d9f26008b8443712541
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">bound_volatile_mem_functor1</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_volatile_mem_functor1< T_return, T_obj, T_arg1 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">sigc::bound_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html#af0b1a108c0080fe202b1d77cae86a7d0">bound_volatile_mem_functor1</a>(T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">sigc::bound_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html#ae51c0fe21853f42cd9890f5f995f4d87">bound_volatile_mem_functor1</a>(T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">sigc::bound_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#ad07b2821f95c27c013af4fdce527c1cb">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor1.html">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html#a38ee12aba5c1d6a7c608165a1137219a">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">sigc::bound_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html#a09b9ac461833030fae01249b50e5984c">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">sigc::bound_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html#a989556175b19d8e13c34727f231228ad">operator()</a>(type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">sigc::bound_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#a69185452103c51af81b78e95504eb95c">sigc::volatile_mem_functor1::operator()</a>(T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor1.html">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#a98cdb61b4c623e44d5b60650098bddfd">sigc::volatile_mem_functor1::operator()</a>(T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor1.html">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#a3bcbf6ae6e950d35e4ac7b33fa066877">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor1.html">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#a30ec3be683a2c466b23da53c8025608b">volatile_mem_functor1</a>()</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor1.html">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#a86d592aee0ca1d853b64b52224054029">volatile_mem_functor1</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor1.html">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_volatile_mem_functor1< T_return, T_obj, T_arg1 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">bound_volatile_mem_functor1</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__volatile__mem__functor1-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_volatile_mem_functor1< T_return, T_obj, T_arg1 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html" title="bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance.">bound_volatile_mem_functor1</a> encapsulates a volatile method with 1 arguments and an object instance.
+ <a href="classsigc_1_1bound__volatile__mem__functor1.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_volatile_mem_functor1< T_return, T_obj, T_arg1 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__volatile__mem__functor1__inherit__graph.png" border="0" usemap="#asigc_1_1bound__volatile__mem__functor1_3_01T__return_00_01T__obj_00_01T__arg1_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__volatile__mem__functor1_3_01T__return_00_01T__obj_00_01T__arg1_01_4_inherit__map" id="asigc_1_1bound__volatile__mem__functor1_3_01T__return_00_01T__obj_00_01T__arg1_01_4_inherit__map">
+<area shape="rect" title="bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance." alt="" coords="5,184,203,240"/>
+<area shape="rect" href="classsigc_1_1volatile__mem__functor1.html" title="volatile_mem_functor1 wraps volatile methods with 1 argument(s)." alt="" coords="26,80,182,136"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a38ee12aba5c1d6a7c608165a1137219a"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html#a38ee12aba5c1d6a7c608165a1137219a">function_type</a></td></tr>
+<tr class="separator:a38ee12aba5c1d6a7c608165a1137219a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1volatile__mem__functor1"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1volatile__mem__functor1')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1volatile__mem__functor1.html">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td></tr>
+<tr class="memitem:a49228c222297c3f116b132370c3f054d inherit pub_types_classsigc_1_1volatile__mem__functor1"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#a49228c222297c3f116b132370c3f054d">function_type</a>) (T_arg1) volatile</td></tr>
+<tr class="separator:a49228c222297c3f116b132370c3f054d inherit pub_types_classsigc_1_1volatile__mem__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3bcbf6ae6e950d35e4ac7b33fa066877 inherit pub_types_classsigc_1_1volatile__mem__functor1"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#a3bcbf6ae6e950d35e4ac7b33fa066877">result_type</a></td></tr>
+<tr class="separator:a3bcbf6ae6e950d35e4ac7b33fa066877 inherit pub_types_classsigc_1_1volatile__mem__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:ae51c0fe21853f42cd9890f5f995f4d87"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html#ae51c0fe21853f42cd9890f5f995f4d87">bound_volatile_mem_functor1</a> (T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html#a38ee12aba5c1d6a7c608165a1137219a">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:ae51c0fe21853f42cd9890f5f995f4d87"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html" title="bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance.">bound_volatile_mem_functor1</a> object that wraps the passed method. <a href="classsigc_1_1bound__volatile__mem__functor1.html#ae51c0fe21853f42cd9890f5f995f4d87">More...</a><br /></td></tr>
+<tr class="separator:ae51c0fe21853f42cd9890f5f995f4d87"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af0b1a108c0080fe202b1d77cae86a7d0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html#af0b1a108c0080fe202b1d77cae86a7d0">bound_volatile_mem_functor1</a> (T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html#a38ee12aba5c1d6a7c608165a1137219a">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:af0b1a108c0080fe202b1d77cae86a7d0"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html" title="bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance.">bound_volatile_mem_functor1</a> object that wraps the passed method. <a href="classsigc_1_1bound__volatile__mem__functor1.html#af0b1a108c0080fe202b1d77cae86a7d0">More...</a><br /></td></tr>
+<tr class="separator:af0b1a108c0080fe202b1d77cae86a7d0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a989556175b19d8e13c34727f231228ad"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html#a989556175b19d8e13c34727f231228ad">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a989556175b19d8e13c34727f231228ad"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__volatile__mem__functor1.html#a989556175b19d8e13c34727f231228ad">More...</a><br /></td></tr>
+<tr class="separator:a989556175b19d8e13c34727f231228ad"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1volatile__mem__functor1"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1volatile__mem__functor1')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1volatile__mem__functor1.html">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td></tr>
+<tr class="memitem:a30ec3be683a2c466b23da53c8025608b inherit pub_methods_classsigc_1_1volatile__mem__functor1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#a30ec3be683a2c466b23da53c8025608b">volatile_mem_functor1</a> ()</td></tr>
+<tr class="memdesc:a30ec3be683a2c466b23da53c8025608b inherit pub_methods_classsigc_1_1volatile__mem__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1volatile__mem__functor1.html#a30ec3be683a2c466b23da53c8025608b">More...</a><br /></td></tr>
+<tr class="separator:a30ec3be683a2c466b23da53c8025608b inherit pub_methods_classsigc_1_1volatile__mem__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a86d592aee0ca1d853b64b52224054029 inherit pub_methods_classsigc_1_1volatile__mem__functor1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#a86d592aee0ca1d853b64b52224054029">volatile_mem_functor1</a> (<a class="el" href="classsigc_1_1volatile__mem__functor1.html#a49228c222297c3f116b132370c3f054d">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a86d592aee0ca1d853b64b52224054029 inherit pub_methods_classsigc_1_1volatile__mem__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1volatile__mem__functor1.html" title="volatile_mem_functor1 wraps volatile methods with 1 argument(s).">volatile_mem_functor1</a> object that wraps the passed method. <a href="classsigc_1_1volatile__mem__functor1.html#a86d592aee0ca1d853b64b52224054029">More...</a><br /></td></tr>
+<tr class="separator:a86d592aee0ca1d853b64b52224054029 inherit pub_methods_classsigc_1_1volatile__mem__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a98cdb61b4c623e44d5b60650098bddfd inherit pub_methods_classsigc_1_1volatile__mem__functor1"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#a98cdb61b4c623e44d5b60650098bddfd">operator()</a> (T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a98cdb61b4c623e44d5b60650098bddfd inherit pub_methods_classsigc_1_1volatile__mem__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor1.html#a98cdb61b4c623e44d5b60650098bddfd">More...</a><br /></td></tr>
+<tr class="separator:a98cdb61b4c623e44d5b60650098bddfd inherit pub_methods_classsigc_1_1volatile__mem__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a69185452103c51af81b78e95504eb95c inherit pub_methods_classsigc_1_1volatile__mem__functor1"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#a69185452103c51af81b78e95504eb95c">operator()</a> (T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a69185452103c51af81b78e95504eb95c inherit pub_methods_classsigc_1_1volatile__mem__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor1.html#a69185452103c51af81b78e95504eb95c">More...</a><br /></td></tr>
+<tr class="separator:a69185452103c51af81b78e95504eb95c inherit pub_methods_classsigc_1_1volatile__mem__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:a09b9ac461833030fae01249b50e5984c"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__limit__reference.html">volatile_limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html#a09b9ac461833030fae01249b50e5984c">obj_</a></td></tr>
+<tr class="separator:a09b9ac461833030fae01249b50e5984c"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1volatile__mem__functor1"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1volatile__mem__functor1')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1volatile__mem__functor1.html">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td></tr>
+<tr class="memitem:ad07b2821f95c27c013af4fdce527c1cb inherit pro_attribs_classsigc_1_1volatile__mem__functor1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#a49228c222297c3f116b132370c3f054d">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#ad07b2821f95c27c013af4fdce527c1cb">func_ptr_</a></td></tr>
+<tr class="separator:ad07b2821f95c27c013af4fdce527c1cb inherit pro_attribs_classsigc_1_1volatile__mem__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1><br />
+class sigc::bound_volatile_mem_functor1< T_return, T_obj, T_arg1 ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html" title="bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance.">bound_volatile_mem_functor1</a> encapsulates a volatile method with 1 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html" title="bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance.">bound_volatile_mem_functor1</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html#a989556175b19d8e13c34727f231228ad" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html#a989556175b19d8e13c34727f231228ad" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a38ee12aba5c1d6a7c608165a1137219a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a38ee12aba5c1d6a7c608165a1137219a">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">sigc::bound_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >::<a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html#a38ee12aba5c1d6a7c608165a1137219a">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="af0b1a108c0080fe202b1d77cae86a7d0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af0b1a108c0080fe202b1d77cae86a7d0">◆ </a></span>bound_volatile_mem_functor1() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">sigc::bound_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >::<a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">bound_volatile_mem_functor1</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html#a38ee12aba5c1d6a7c608165a1137219a">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html" title="bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance.">bound_volatile_mem_functor1</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000179">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html#a989556175b19d8e13c34727f231228ad" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="ae51c0fe21853f42cd9890f5f995f4d87"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae51c0fe21853f42cd9890f5f995f4d87">◆ </a></span>bound_volatile_mem_functor1() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">sigc::bound_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >::<a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">bound_volatile_mem_functor1</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html#a38ee12aba5c1d6a7c608165a1137219a">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html" title="bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance.">bound_volatile_mem_functor1</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html#a989556175b19d8e13c34727f231228ad" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a989556175b19d8e13c34727f231228ad"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a989556175b19d8e13c34727f231228ad">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">sigc::bound_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a09b9ac461833030fae01249b50e5984c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a09b9ac461833030fae01249b50e5984c">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__limit__reference.html">volatile_limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">sigc::bound_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_volatile_mem_functor1< T_return, T_obj, T_arg1 >" name="sigc::bound_volatile_mem_functor1< T_return, T_obj, T_arg1 >">
+<area shape="rect" id="node1" title="bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance." alt="" coords="5,184,203,240"/>
+<area shape="rect" id="node2" href="$classsigc_1_1volatile__mem__functor1.html" title="volatile_mem_functor1 wraps volatile methods with 1 argument(s)." alt="" coords="26,80,182,136"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
--- /dev/null
+81aeaec8ee46bc160f801f415a7e8509
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">bound_volatile_mem_functor2</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">sigc::bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#af2222c46ab0b47bd59af92ad509ef6fb">bound_volatile_mem_functor2</a>(T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">sigc::bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#ac3a72dc9eb316e9f096cb0a93792e368">bound_volatile_mem_functor2</a>(T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">sigc::bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#aafe942fe06b2687338ea82b058412d07">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor2.html">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#a16d5240b9bbb31ae266725d20b0f37d7">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">sigc::bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#a80858a8bbb89469136b8e476d0bae0e6">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">sigc::bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#a5a93614f492dacd37dd1cfd94cc033b3">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">sigc::bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#ac4c64a4812347e17744e33e5e37775d7">sigc::volatile_mem_functor2::operator()</a>(T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor2.html">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#a814c8abe52fa858da9f8dfbda8efafc9">sigc::volatile_mem_functor2::operator()</a>(T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor2.html">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#a67719071ed0eacd994fa6fe300cfb24d">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor2.html">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#a273bbe27bc7b190d8457408cd328c1f9">volatile_mem_functor2</a>()</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor2.html">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#acba5e052ebb8884ff02cab194a2f794e">volatile_mem_functor2</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor2.html">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">bound_volatile_mem_functor2</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__volatile__mem__functor2-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html" title="bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance.">bound_volatile_mem_functor2</a> encapsulates a volatile method with 2 arguments and an object instance.
+ <a href="classsigc_1_1bound__volatile__mem__functor2.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__volatile__mem__functor2__inherit__graph.png" border="0" usemap="#asigc_1_1bound__volatile__mem__functor2_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__volatile__mem__functor2_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_01_4_inherit__map" id="asigc_1_1bound__volatile__mem__functor2_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_01_4_inherit__map">
+<area shape="rect" title="bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance." alt="" coords="5,184,203,240"/>
+<area shape="rect" href="classsigc_1_1volatile__mem__functor2.html" title="volatile_mem_functor2 wraps volatile methods with 2 argument(s)." alt="" coords="14,80,194,136"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a16d5240b9bbb31ae266725d20b0f37d7"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#a16d5240b9bbb31ae266725d20b0f37d7">function_type</a></td></tr>
+<tr class="separator:a16d5240b9bbb31ae266725d20b0f37d7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1volatile__mem__functor2"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1volatile__mem__functor2')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1volatile__mem__functor2.html">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td></tr>
+<tr class="memitem:a5faa6d84f05d64ff92e9e4ba6b8bcc1f inherit pub_types_classsigc_1_1volatile__mem__functor2"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#a5faa6d84f05d64ff92e9e4ba6b8bcc1f">function_type</a>) (T_arg1, T_arg2) volatile</td></tr>
+<tr class="separator:a5faa6d84f05d64ff92e9e4ba6b8bcc1f inherit pub_types_classsigc_1_1volatile__mem__functor2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a67719071ed0eacd994fa6fe300cfb24d inherit pub_types_classsigc_1_1volatile__mem__functor2"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#a67719071ed0eacd994fa6fe300cfb24d">result_type</a></td></tr>
+<tr class="separator:a67719071ed0eacd994fa6fe300cfb24d inherit pub_types_classsigc_1_1volatile__mem__functor2"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:ac3a72dc9eb316e9f096cb0a93792e368"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#ac3a72dc9eb316e9f096cb0a93792e368">bound_volatile_mem_functor2</a> (T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#a16d5240b9bbb31ae266725d20b0f37d7">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:ac3a72dc9eb316e9f096cb0a93792e368"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html" title="bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance.">bound_volatile_mem_functor2</a> object that wraps the passed method. <a href="classsigc_1_1bound__volatile__mem__functor2.html#ac3a72dc9eb316e9f096cb0a93792e368">More...</a><br /></td></tr>
+<tr class="separator:ac3a72dc9eb316e9f096cb0a93792e368"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2222c46ab0b47bd59af92ad509ef6fb"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#af2222c46ab0b47bd59af92ad509ef6fb">bound_volatile_mem_functor2</a> (T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#a16d5240b9bbb31ae266725d20b0f37d7">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:af2222c46ab0b47bd59af92ad509ef6fb"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html" title="bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance.">bound_volatile_mem_functor2</a> object that wraps the passed method. <a href="classsigc_1_1bound__volatile__mem__functor2.html#af2222c46ab0b47bd59af92ad509ef6fb">More...</a><br /></td></tr>
+<tr class="separator:af2222c46ab0b47bd59af92ad509ef6fb"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5a93614f492dacd37dd1cfd94cc033b3"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#a5a93614f492dacd37dd1cfd94cc033b3">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:a5a93614f492dacd37dd1cfd94cc033b3"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__volatile__mem__functor2.html#a5a93614f492dacd37dd1cfd94cc033b3">More...</a><br /></td></tr>
+<tr class="separator:a5a93614f492dacd37dd1cfd94cc033b3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1volatile__mem__functor2"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1volatile__mem__functor2')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1volatile__mem__functor2.html">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td></tr>
+<tr class="memitem:a273bbe27bc7b190d8457408cd328c1f9 inherit pub_methods_classsigc_1_1volatile__mem__functor2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#a273bbe27bc7b190d8457408cd328c1f9">volatile_mem_functor2</a> ()</td></tr>
+<tr class="memdesc:a273bbe27bc7b190d8457408cd328c1f9 inherit pub_methods_classsigc_1_1volatile__mem__functor2"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1volatile__mem__functor2.html#a273bbe27bc7b190d8457408cd328c1f9">More...</a><br /></td></tr>
+<tr class="separator:a273bbe27bc7b190d8457408cd328c1f9 inherit pub_methods_classsigc_1_1volatile__mem__functor2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acba5e052ebb8884ff02cab194a2f794e inherit pub_methods_classsigc_1_1volatile__mem__functor2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#acba5e052ebb8884ff02cab194a2f794e">volatile_mem_functor2</a> (<a class="el" href="classsigc_1_1volatile__mem__functor2.html#a5faa6d84f05d64ff92e9e4ba6b8bcc1f">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:acba5e052ebb8884ff02cab194a2f794e inherit pub_methods_classsigc_1_1volatile__mem__functor2"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1volatile__mem__functor2.html" title="volatile_mem_functor2 wraps volatile methods with 2 argument(s).">volatile_mem_functor2</a> object that wraps the passed method. <a href="classsigc_1_1volatile__mem__functor2.html#acba5e052ebb8884ff02cab194a2f794e">More...</a><br /></td></tr>
+<tr class="separator:acba5e052ebb8884ff02cab194a2f794e inherit pub_methods_classsigc_1_1volatile__mem__functor2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a814c8abe52fa858da9f8dfbda8efafc9 inherit pub_methods_classsigc_1_1volatile__mem__functor2"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#a814c8abe52fa858da9f8dfbda8efafc9">operator()</a> (T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:a814c8abe52fa858da9f8dfbda8efafc9 inherit pub_methods_classsigc_1_1volatile__mem__functor2"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor2.html#a814c8abe52fa858da9f8dfbda8efafc9">More...</a><br /></td></tr>
+<tr class="separator:a814c8abe52fa858da9f8dfbda8efafc9 inherit pub_methods_classsigc_1_1volatile__mem__functor2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac4c64a4812347e17744e33e5e37775d7 inherit pub_methods_classsigc_1_1volatile__mem__functor2"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#ac4c64a4812347e17744e33e5e37775d7">operator()</a> (T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:ac4c64a4812347e17744e33e5e37775d7 inherit pub_methods_classsigc_1_1volatile__mem__functor2"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor2.html#ac4c64a4812347e17744e33e5e37775d7">More...</a><br /></td></tr>
+<tr class="separator:ac4c64a4812347e17744e33e5e37775d7 inherit pub_methods_classsigc_1_1volatile__mem__functor2"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:a80858a8bbb89469136b8e476d0bae0e6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__limit__reference.html">volatile_limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#a80858a8bbb89469136b8e476d0bae0e6">obj_</a></td></tr>
+<tr class="separator:a80858a8bbb89469136b8e476d0bae0e6"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1volatile__mem__functor2"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1volatile__mem__functor2')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1volatile__mem__functor2.html">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td></tr>
+<tr class="memitem:aafe942fe06b2687338ea82b058412d07 inherit pro_attribs_classsigc_1_1volatile__mem__functor2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#a5faa6d84f05d64ff92e9e4ba6b8bcc1f">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#aafe942fe06b2687338ea82b058412d07">func_ptr_</a></td></tr>
+<tr class="separator:aafe942fe06b2687338ea82b058412d07 inherit pro_attribs_classsigc_1_1volatile__mem__functor2"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2><br />
+class sigc::bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html" title="bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance.">bound_volatile_mem_functor2</a> encapsulates a volatile method with 2 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html" title="bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance.">bound_volatile_mem_functor2</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#a5a93614f492dacd37dd1cfd94cc033b3" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#a5a93614f492dacd37dd1cfd94cc033b3" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#a5a93614f492dacd37dd1cfd94cc033b3" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a16d5240b9bbb31ae266725d20b0f37d7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a16d5240b9bbb31ae266725d20b0f37d7">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">sigc::bound_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#a16d5240b9bbb31ae266725d20b0f37d7">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="af2222c46ab0b47bd59af92ad509ef6fb"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af2222c46ab0b47bd59af92ad509ef6fb">◆ </a></span>bound_volatile_mem_functor2() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">sigc::bound_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">bound_volatile_mem_functor2</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#a16d5240b9bbb31ae266725d20b0f37d7">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html" title="bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance.">bound_volatile_mem_functor2</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000180">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#a5a93614f492dacd37dd1cfd94cc033b3" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="ac3a72dc9eb316e9f096cb0a93792e368"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac3a72dc9eb316e9f096cb0a93792e368">◆ </a></span>bound_volatile_mem_functor2() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">sigc::bound_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">bound_volatile_mem_functor2</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#a16d5240b9bbb31ae266725d20b0f37d7">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html" title="bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance.">bound_volatile_mem_functor2</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#a5a93614f492dacd37dd1cfd94cc033b3" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a5a93614f492dacd37dd1cfd94cc033b3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5a93614f492dacd37dd1cfd94cc033b3">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">sigc::bound_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a80858a8bbb89469136b8e476d0bae0e6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a80858a8bbb89469136b8e476d0bae0e6">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__limit__reference.html">volatile_limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">sigc::bound_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >" name="sigc::bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >">
+<area shape="rect" id="node1" title="bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance." alt="" coords="5,184,203,240"/>
+<area shape="rect" id="node2" href="$classsigc_1_1volatile__mem__functor2.html" title="volatile_mem_functor2 wraps volatile methods with 2 argument(s)." alt="" coords="14,80,194,136"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
--- /dev/null
+33e5a12c26e80998c0d71884f22f273d
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">bound_volatile_mem_functor3</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">sigc::bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#a21c0be5f093ddcd084cc5ad172ceaf92">bound_volatile_mem_functor3</a>(T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">sigc::bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#a1f2aacad170885008a58975c8562a863">bound_volatile_mem_functor3</a>(T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">sigc::bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#acf6a8aebcf4de461e03e9b994a807362">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor3.html">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#abc967931a7ab1411e02c022035073be5">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">sigc::bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#a01d01f9945bd93e227403cdbb8271e2a">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">sigc::bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#af5b4934a8e75fd7c32d41a989ec67f66">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">sigc::bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#a39944451f3bb1538828e45b66f082ea0">sigc::volatile_mem_functor3::operator()</a>(T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor3.html">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#ab525bf6e0a4057a4f3f8f98ff6c1bd74">sigc::volatile_mem_functor3::operator()</a>(T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor3.html">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#a229fe43026e97bbcf80215ea8e9fa828">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor3.html">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#ad2319eebf06194ff516c27f581cbd7a5">volatile_mem_functor3</a>()</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor3.html">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#a2364e6ab68a8128ba9e9973c66c0ce1d">volatile_mem_functor3</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor3.html">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">bound_volatile_mem_functor3</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__volatile__mem__functor3-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html" title="bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance.">bound_volatile_mem_functor3</a> encapsulates a volatile method with 3 arguments and an object instance.
+ <a href="classsigc_1_1bound__volatile__mem__functor3.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__volatile__mem__functor3__inherit__graph.png" border="0" usemap="#asigc_1_1bound__volatile__mem__functor3_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__volatile__mem__functor3_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_01_4_inherit__map" id="asigc_1_1bound__volatile__mem__functor3_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_01_4_inherit__map">
+<area shape="rect" title="bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance." alt="" coords="5,199,203,269"/>
+<area shape="rect" href="classsigc_1_1volatile__mem__functor3.html" title="volatile_mem_functor3 wraps volatile methods with 3 argument(s)." alt="" coords="19,80,189,151"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:abc967931a7ab1411e02c022035073be5"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#abc967931a7ab1411e02c022035073be5">function_type</a></td></tr>
+<tr class="separator:abc967931a7ab1411e02c022035073be5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1volatile__mem__functor3"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1volatile__mem__functor3')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1volatile__mem__functor3.html">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td></tr>
+<tr class="memitem:aadf62624c12ef82ade8114184f0882c9 inherit pub_types_classsigc_1_1volatile__mem__functor3"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#aadf62624c12ef82ade8114184f0882c9">function_type</a>) (T_arg1, T_arg2, T_arg3) volatile</td></tr>
+<tr class="separator:aadf62624c12ef82ade8114184f0882c9 inherit pub_types_classsigc_1_1volatile__mem__functor3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a229fe43026e97bbcf80215ea8e9fa828 inherit pub_types_classsigc_1_1volatile__mem__functor3"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#a229fe43026e97bbcf80215ea8e9fa828">result_type</a></td></tr>
+<tr class="separator:a229fe43026e97bbcf80215ea8e9fa828 inherit pub_types_classsigc_1_1volatile__mem__functor3"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a1f2aacad170885008a58975c8562a863"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#a1f2aacad170885008a58975c8562a863">bound_volatile_mem_functor3</a> (T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#abc967931a7ab1411e02c022035073be5">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a1f2aacad170885008a58975c8562a863"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html" title="bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance.">bound_volatile_mem_functor3</a> object that wraps the passed method. <a href="classsigc_1_1bound__volatile__mem__functor3.html#a1f2aacad170885008a58975c8562a863">More...</a><br /></td></tr>
+<tr class="separator:a1f2aacad170885008a58975c8562a863"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21c0be5f093ddcd084cc5ad172ceaf92"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#a21c0be5f093ddcd084cc5ad172ceaf92">bound_volatile_mem_functor3</a> (T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#abc967931a7ab1411e02c022035073be5">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a21c0be5f093ddcd084cc5ad172ceaf92"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html" title="bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance.">bound_volatile_mem_functor3</a> object that wraps the passed method. <a href="classsigc_1_1bound__volatile__mem__functor3.html#a21c0be5f093ddcd084cc5ad172ceaf92">More...</a><br /></td></tr>
+<tr class="separator:a21c0be5f093ddcd084cc5ad172ceaf92"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af5b4934a8e75fd7c32d41a989ec67f66"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#af5b4934a8e75fd7c32d41a989ec67f66">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:af5b4934a8e75fd7c32d41a989ec67f66"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__volatile__mem__functor3.html#af5b4934a8e75fd7c32d41a989ec67f66">More...</a><br /></td></tr>
+<tr class="separator:af5b4934a8e75fd7c32d41a989ec67f66"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1volatile__mem__functor3"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1volatile__mem__functor3')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1volatile__mem__functor3.html">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td></tr>
+<tr class="memitem:ad2319eebf06194ff516c27f581cbd7a5 inherit pub_methods_classsigc_1_1volatile__mem__functor3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#ad2319eebf06194ff516c27f581cbd7a5">volatile_mem_functor3</a> ()</td></tr>
+<tr class="memdesc:ad2319eebf06194ff516c27f581cbd7a5 inherit pub_methods_classsigc_1_1volatile__mem__functor3"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1volatile__mem__functor3.html#ad2319eebf06194ff516c27f581cbd7a5">More...</a><br /></td></tr>
+<tr class="separator:ad2319eebf06194ff516c27f581cbd7a5 inherit pub_methods_classsigc_1_1volatile__mem__functor3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2364e6ab68a8128ba9e9973c66c0ce1d inherit pub_methods_classsigc_1_1volatile__mem__functor3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#a2364e6ab68a8128ba9e9973c66c0ce1d">volatile_mem_functor3</a> (<a class="el" href="classsigc_1_1volatile__mem__functor3.html#aadf62624c12ef82ade8114184f0882c9">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a2364e6ab68a8128ba9e9973c66c0ce1d inherit pub_methods_classsigc_1_1volatile__mem__functor3"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1volatile__mem__functor3.html" title="volatile_mem_functor3 wraps volatile methods with 3 argument(s).">volatile_mem_functor3</a> object that wraps the passed method. <a href="classsigc_1_1volatile__mem__functor3.html#a2364e6ab68a8128ba9e9973c66c0ce1d">More...</a><br /></td></tr>
+<tr class="separator:a2364e6ab68a8128ba9e9973c66c0ce1d inherit pub_methods_classsigc_1_1volatile__mem__functor3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab525bf6e0a4057a4f3f8f98ff6c1bd74 inherit pub_methods_classsigc_1_1volatile__mem__functor3"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#ab525bf6e0a4057a4f3f8f98ff6c1bd74">operator()</a> (T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:ab525bf6e0a4057a4f3f8f98ff6c1bd74 inherit pub_methods_classsigc_1_1volatile__mem__functor3"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor3.html#ab525bf6e0a4057a4f3f8f98ff6c1bd74">More...</a><br /></td></tr>
+<tr class="separator:ab525bf6e0a4057a4f3f8f98ff6c1bd74 inherit pub_methods_classsigc_1_1volatile__mem__functor3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a39944451f3bb1538828e45b66f082ea0 inherit pub_methods_classsigc_1_1volatile__mem__functor3"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#a39944451f3bb1538828e45b66f082ea0">operator()</a> (T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:a39944451f3bb1538828e45b66f082ea0 inherit pub_methods_classsigc_1_1volatile__mem__functor3"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor3.html#a39944451f3bb1538828e45b66f082ea0">More...</a><br /></td></tr>
+<tr class="separator:a39944451f3bb1538828e45b66f082ea0 inherit pub_methods_classsigc_1_1volatile__mem__functor3"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:a01d01f9945bd93e227403cdbb8271e2a"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__limit__reference.html">volatile_limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#a01d01f9945bd93e227403cdbb8271e2a">obj_</a></td></tr>
+<tr class="separator:a01d01f9945bd93e227403cdbb8271e2a"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1volatile__mem__functor3"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1volatile__mem__functor3')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1volatile__mem__functor3.html">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td></tr>
+<tr class="memitem:acf6a8aebcf4de461e03e9b994a807362 inherit pro_attribs_classsigc_1_1volatile__mem__functor3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#aadf62624c12ef82ade8114184f0882c9">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#acf6a8aebcf4de461e03e9b994a807362">func_ptr_</a></td></tr>
+<tr class="separator:acf6a8aebcf4de461e03e9b994a807362 inherit pro_attribs_classsigc_1_1volatile__mem__functor3"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3><br />
+class sigc::bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html" title="bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance.">bound_volatile_mem_functor3</a> encapsulates a volatile method with 3 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html" title="bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance.">bound_volatile_mem_functor3</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#af5b4934a8e75fd7c32d41a989ec67f66" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#af5b4934a8e75fd7c32d41a989ec67f66" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#af5b4934a8e75fd7c32d41a989ec67f66" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#af5b4934a8e75fd7c32d41a989ec67f66" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="abc967931a7ab1411e02c022035073be5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abc967931a7ab1411e02c022035073be5">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">sigc::bound_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#abc967931a7ab1411e02c022035073be5">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a21c0be5f093ddcd084cc5ad172ceaf92"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a21c0be5f093ddcd084cc5ad172ceaf92">◆ </a></span>bound_volatile_mem_functor3() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">sigc::bound_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">bound_volatile_mem_functor3</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#abc967931a7ab1411e02c022035073be5">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html" title="bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance.">bound_volatile_mem_functor3</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000181">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#af5b4934a8e75fd7c32d41a989ec67f66" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a1f2aacad170885008a58975c8562a863"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1f2aacad170885008a58975c8562a863">◆ </a></span>bound_volatile_mem_functor3() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">sigc::bound_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">bound_volatile_mem_functor3</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#abc967931a7ab1411e02c022035073be5">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html" title="bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance.">bound_volatile_mem_functor3</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#af5b4934a8e75fd7c32d41a989ec67f66" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="af5b4934a8e75fd7c32d41a989ec67f66"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af5b4934a8e75fd7c32d41a989ec67f66">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">sigc::bound_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a01d01f9945bd93e227403cdbb8271e2a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a01d01f9945bd93e227403cdbb8271e2a">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__limit__reference.html">volatile_limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">sigc::bound_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >" name="sigc::bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >">
+<area shape="rect" id="node1" title="bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance." alt="" coords="5,199,203,269"/>
+<area shape="rect" id="node2" href="$classsigc_1_1volatile__mem__functor3.html" title="volatile_mem_functor3 wraps volatile methods with 3 argument(s)." alt="" coords="19,80,189,151"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
--- /dev/null
+f54d3de96a24e0b34d402f8e08ee1b7b
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">bound_volatile_mem_functor4</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">sigc::bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#ae2385ee536e72cfbb0d945ba770f2e69">bound_volatile_mem_functor4</a>(T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">sigc::bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#a7264500594318b92a0a668fcfbbeffbc">bound_volatile_mem_functor4</a>(T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">sigc::bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#a176ab2202482276e79e6d71ff839c31d">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor4.html">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#a7a30b6a2e3067254fdea50104fea8469">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">sigc::bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#a4bb276cfe8c35645f166cde087f5d17f">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">sigc::bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#a22702ad82b54c77d93fb6d0481896d8f">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">sigc::bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#a86a0e482790971e3674b9ba488e10127">sigc::volatile_mem_functor4::operator()</a>(T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor4.html">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#a58491d7fd980863c7abd311624ada052">sigc::volatile_mem_functor4::operator()</a>(T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor4.html">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#a58dd95fa47c02a9ba6340682c7dbbcb0">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor4.html">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#a5ba462855081b617085e59e7566927a7">volatile_mem_functor4</a>()</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor4.html">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#ab86348ff91ed7ce4cadff97c157e4024">volatile_mem_functor4</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor4.html">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">bound_volatile_mem_functor4</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__volatile__mem__functor4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html" title="bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance.">bound_volatile_mem_functor4</a> encapsulates a volatile method with 4 arguments and an object instance.
+ <a href="classsigc_1_1bound__volatile__mem__functor4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__volatile__mem__functor4__inherit__graph.png" border="0" usemap="#asigc_1_1bound__volatile__mem__functor4_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__volatile__mem__functor4_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_01_4_inherit__map" id="asigc_1_1bound__volatile__mem__functor4_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_01_4_inherit__map">
+<area shape="rect" title="bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance." alt="" coords="5,199,203,269"/>
+<area shape="rect" href="classsigc_1_1volatile__mem__functor4.html" title="volatile_mem_functor4 wraps volatile methods with 4 argument(s)." alt="" coords="19,80,189,151"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a7a30b6a2e3067254fdea50104fea8469"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#a7a30b6a2e3067254fdea50104fea8469">function_type</a></td></tr>
+<tr class="separator:a7a30b6a2e3067254fdea50104fea8469"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1volatile__mem__functor4"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1volatile__mem__functor4')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1volatile__mem__functor4.html">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td></tr>
+<tr class="memitem:a697cad0c578cd4ba3e04f6db8a39e283 inherit pub_types_classsigc_1_1volatile__mem__functor4"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#a697cad0c578cd4ba3e04f6db8a39e283">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4) volatile</td></tr>
+<tr class="separator:a697cad0c578cd4ba3e04f6db8a39e283 inherit pub_types_classsigc_1_1volatile__mem__functor4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a58dd95fa47c02a9ba6340682c7dbbcb0 inherit pub_types_classsigc_1_1volatile__mem__functor4"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#a58dd95fa47c02a9ba6340682c7dbbcb0">result_type</a></td></tr>
+<tr class="separator:a58dd95fa47c02a9ba6340682c7dbbcb0 inherit pub_types_classsigc_1_1volatile__mem__functor4"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a7264500594318b92a0a668fcfbbeffbc"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#a7264500594318b92a0a668fcfbbeffbc">bound_volatile_mem_functor4</a> (T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#a7a30b6a2e3067254fdea50104fea8469">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a7264500594318b92a0a668fcfbbeffbc"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html" title="bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance.">bound_volatile_mem_functor4</a> object that wraps the passed method. <a href="classsigc_1_1bound__volatile__mem__functor4.html#a7264500594318b92a0a668fcfbbeffbc">More...</a><br /></td></tr>
+<tr class="separator:a7264500594318b92a0a668fcfbbeffbc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae2385ee536e72cfbb0d945ba770f2e69"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#ae2385ee536e72cfbb0d945ba770f2e69">bound_volatile_mem_functor4</a> (T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#a7a30b6a2e3067254fdea50104fea8469">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:ae2385ee536e72cfbb0d945ba770f2e69"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html" title="bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance.">bound_volatile_mem_functor4</a> object that wraps the passed method. <a href="classsigc_1_1bound__volatile__mem__functor4.html#ae2385ee536e72cfbb0d945ba770f2e69">More...</a><br /></td></tr>
+<tr class="separator:ae2385ee536e72cfbb0d945ba770f2e69"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a22702ad82b54c77d93fb6d0481896d8f"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#a22702ad82b54c77d93fb6d0481896d8f">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:a22702ad82b54c77d93fb6d0481896d8f"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__volatile__mem__functor4.html#a22702ad82b54c77d93fb6d0481896d8f">More...</a><br /></td></tr>
+<tr class="separator:a22702ad82b54c77d93fb6d0481896d8f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1volatile__mem__functor4"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1volatile__mem__functor4')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1volatile__mem__functor4.html">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td></tr>
+<tr class="memitem:a5ba462855081b617085e59e7566927a7 inherit pub_methods_classsigc_1_1volatile__mem__functor4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#a5ba462855081b617085e59e7566927a7">volatile_mem_functor4</a> ()</td></tr>
+<tr class="memdesc:a5ba462855081b617085e59e7566927a7 inherit pub_methods_classsigc_1_1volatile__mem__functor4"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1volatile__mem__functor4.html#a5ba462855081b617085e59e7566927a7">More...</a><br /></td></tr>
+<tr class="separator:a5ba462855081b617085e59e7566927a7 inherit pub_methods_classsigc_1_1volatile__mem__functor4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab86348ff91ed7ce4cadff97c157e4024 inherit pub_methods_classsigc_1_1volatile__mem__functor4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#ab86348ff91ed7ce4cadff97c157e4024">volatile_mem_functor4</a> (<a class="el" href="classsigc_1_1volatile__mem__functor4.html#a697cad0c578cd4ba3e04f6db8a39e283">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:ab86348ff91ed7ce4cadff97c157e4024 inherit pub_methods_classsigc_1_1volatile__mem__functor4"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1volatile__mem__functor4.html" title="volatile_mem_functor4 wraps volatile methods with 4 argument(s).">volatile_mem_functor4</a> object that wraps the passed method. <a href="classsigc_1_1volatile__mem__functor4.html#ab86348ff91ed7ce4cadff97c157e4024">More...</a><br /></td></tr>
+<tr class="separator:ab86348ff91ed7ce4cadff97c157e4024 inherit pub_methods_classsigc_1_1volatile__mem__functor4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a58491d7fd980863c7abd311624ada052 inherit pub_methods_classsigc_1_1volatile__mem__functor4"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#a58491d7fd980863c7abd311624ada052">operator()</a> (T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:a58491d7fd980863c7abd311624ada052 inherit pub_methods_classsigc_1_1volatile__mem__functor4"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor4.html#a58491d7fd980863c7abd311624ada052">More...</a><br /></td></tr>
+<tr class="separator:a58491d7fd980863c7abd311624ada052 inherit pub_methods_classsigc_1_1volatile__mem__functor4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a86a0e482790971e3674b9ba488e10127 inherit pub_methods_classsigc_1_1volatile__mem__functor4"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#a86a0e482790971e3674b9ba488e10127">operator()</a> (T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:a86a0e482790971e3674b9ba488e10127 inherit pub_methods_classsigc_1_1volatile__mem__functor4"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor4.html#a86a0e482790971e3674b9ba488e10127">More...</a><br /></td></tr>
+<tr class="separator:a86a0e482790971e3674b9ba488e10127 inherit pub_methods_classsigc_1_1volatile__mem__functor4"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:a4bb276cfe8c35645f166cde087f5d17f"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__limit__reference.html">volatile_limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#a4bb276cfe8c35645f166cde087f5d17f">obj_</a></td></tr>
+<tr class="separator:a4bb276cfe8c35645f166cde087f5d17f"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1volatile__mem__functor4"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1volatile__mem__functor4')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1volatile__mem__functor4.html">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td></tr>
+<tr class="memitem:a176ab2202482276e79e6d71ff839c31d inherit pro_attribs_classsigc_1_1volatile__mem__functor4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#a697cad0c578cd4ba3e04f6db8a39e283">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#a176ab2202482276e79e6d71ff839c31d">func_ptr_</a></td></tr>
+<tr class="separator:a176ab2202482276e79e6d71ff839c31d inherit pro_attribs_classsigc_1_1volatile__mem__functor4"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4><br />
+class sigc::bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html" title="bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance.">bound_volatile_mem_functor4</a> encapsulates a volatile method with 4 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html" title="bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance.">bound_volatile_mem_functor4</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#a22702ad82b54c77d93fb6d0481896d8f" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#a22702ad82b54c77d93fb6d0481896d8f" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#a22702ad82b54c77d93fb6d0481896d8f" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#a22702ad82b54c77d93fb6d0481896d8f" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#a22702ad82b54c77d93fb6d0481896d8f" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a7a30b6a2e3067254fdea50104fea8469"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7a30b6a2e3067254fdea50104fea8469">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">sigc::bound_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#a7a30b6a2e3067254fdea50104fea8469">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="ae2385ee536e72cfbb0d945ba770f2e69"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae2385ee536e72cfbb0d945ba770f2e69">◆ </a></span>bound_volatile_mem_functor4() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">sigc::bound_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">bound_volatile_mem_functor4</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#a7a30b6a2e3067254fdea50104fea8469">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html" title="bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance.">bound_volatile_mem_functor4</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000182">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#a22702ad82b54c77d93fb6d0481896d8f" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a7264500594318b92a0a668fcfbbeffbc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7264500594318b92a0a668fcfbbeffbc">◆ </a></span>bound_volatile_mem_functor4() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">sigc::bound_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">bound_volatile_mem_functor4</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#a7a30b6a2e3067254fdea50104fea8469">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html" title="bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance.">bound_volatile_mem_functor4</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#a22702ad82b54c77d93fb6d0481896d8f" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a22702ad82b54c77d93fb6d0481896d8f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a22702ad82b54c77d93fb6d0481896d8f">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">sigc::bound_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a4bb276cfe8c35645f166cde087f5d17f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4bb276cfe8c35645f166cde087f5d17f">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__limit__reference.html">volatile_limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">sigc::bound_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >" name="sigc::bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >">
+<area shape="rect" id="node1" title="bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance." alt="" coords="5,199,203,269"/>
+<area shape="rect" id="node2" href="$classsigc_1_1volatile__mem__functor4.html" title="volatile_mem_functor4 wraps volatile methods with 4 argument(s)." alt="" coords="19,80,189,151"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
--- /dev/null
+b0e13b8d8bd6e37ce4cad3a0c7dd5371
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">bound_volatile_mem_functor5</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">sigc::bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#af5e4db24b5ba51d92746aa3fee080d49">bound_volatile_mem_functor5</a>(T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">sigc::bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#a01734765e6a89bd0ab89063f130541e3">bound_volatile_mem_functor5</a>(T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">sigc::bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#a01d38ddf6e713a47199fba85fd5a8092">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor5.html">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#a1561f499bd4d950fd36ee43ee60db585">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">sigc::bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#ae17c42b74b72c74f3a7e4d5faadaa761">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">sigc::bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#aaf0765f195ee2efef0536dfb854af9e4">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">sigc::bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#ab6449c487e42fc9810c0f8d5a6cc243f">sigc::volatile_mem_functor5::operator()</a>(T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor5.html">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#a4a4b9b8ce1ce396ed9fa355ed56cf7b2">sigc::volatile_mem_functor5::operator()</a>(T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor5.html">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#ab647ea2e44db475cc2d4bae8be842127">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor5.html">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#abe1011a71cd8e78d248e072fb7d60231">volatile_mem_functor5</a>()</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor5.html">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#a98e43ac4bafb96958bbbf658154794d0">volatile_mem_functor5</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor5.html">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">bound_volatile_mem_functor5</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__volatile__mem__functor5-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html" title="bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance.">bound_volatile_mem_functor5</a> encapsulates a volatile method with 5 arguments and an object instance.
+ <a href="classsigc_1_1bound__volatile__mem__functor5.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__volatile__mem__functor5__inherit__graph.png" border="0" usemap="#asigc_1_1bound__volatile__mem__functor5_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__volatile__mem__functor5_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_01_4_inherit__map" id="asigc_1_1bound__volatile__mem__functor5_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_01_4_inherit__map">
+<area shape="rect" title="bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance." alt="" coords="431,5,628,76"/>
+<area shape="rect" href="classsigc_1_1volatile__mem__functor5.html" title="volatile_mem_functor5 wraps volatile methods with 5 argument(s)." alt="" coords="193,5,383,76"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,27,145,54"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a1561f499bd4d950fd36ee43ee60db585"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#a1561f499bd4d950fd36ee43ee60db585">function_type</a></td></tr>
+<tr class="separator:a1561f499bd4d950fd36ee43ee60db585"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1volatile__mem__functor5"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1volatile__mem__functor5')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1volatile__mem__functor5.html">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td></tr>
+<tr class="memitem:a43ce719034586bbd097c823376c288ef inherit pub_types_classsigc_1_1volatile__mem__functor5"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#a43ce719034586bbd097c823376c288ef">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile</td></tr>
+<tr class="separator:a43ce719034586bbd097c823376c288ef inherit pub_types_classsigc_1_1volatile__mem__functor5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab647ea2e44db475cc2d4bae8be842127 inherit pub_types_classsigc_1_1volatile__mem__functor5"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#ab647ea2e44db475cc2d4bae8be842127">result_type</a></td></tr>
+<tr class="separator:ab647ea2e44db475cc2d4bae8be842127 inherit pub_types_classsigc_1_1volatile__mem__functor5"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a01734765e6a89bd0ab89063f130541e3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#a01734765e6a89bd0ab89063f130541e3">bound_volatile_mem_functor5</a> (T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#a1561f499bd4d950fd36ee43ee60db585">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a01734765e6a89bd0ab89063f130541e3"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html" title="bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance.">bound_volatile_mem_functor5</a> object that wraps the passed method. <a href="classsigc_1_1bound__volatile__mem__functor5.html#a01734765e6a89bd0ab89063f130541e3">More...</a><br /></td></tr>
+<tr class="separator:a01734765e6a89bd0ab89063f130541e3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af5e4db24b5ba51d92746aa3fee080d49"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#af5e4db24b5ba51d92746aa3fee080d49">bound_volatile_mem_functor5</a> (T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#a1561f499bd4d950fd36ee43ee60db585">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:af5e4db24b5ba51d92746aa3fee080d49"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html" title="bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance.">bound_volatile_mem_functor5</a> object that wraps the passed method. <a href="classsigc_1_1bound__volatile__mem__functor5.html#af5e4db24b5ba51d92746aa3fee080d49">More...</a><br /></td></tr>
+<tr class="separator:af5e4db24b5ba51d92746aa3fee080d49"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aaf0765f195ee2efef0536dfb854af9e4"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#aaf0765f195ee2efef0536dfb854af9e4">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:aaf0765f195ee2efef0536dfb854af9e4"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__volatile__mem__functor5.html#aaf0765f195ee2efef0536dfb854af9e4">More...</a><br /></td></tr>
+<tr class="separator:aaf0765f195ee2efef0536dfb854af9e4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1volatile__mem__functor5"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1volatile__mem__functor5')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1volatile__mem__functor5.html">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td></tr>
+<tr class="memitem:abe1011a71cd8e78d248e072fb7d60231 inherit pub_methods_classsigc_1_1volatile__mem__functor5"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#abe1011a71cd8e78d248e072fb7d60231">volatile_mem_functor5</a> ()</td></tr>
+<tr class="memdesc:abe1011a71cd8e78d248e072fb7d60231 inherit pub_methods_classsigc_1_1volatile__mem__functor5"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1volatile__mem__functor5.html#abe1011a71cd8e78d248e072fb7d60231">More...</a><br /></td></tr>
+<tr class="separator:abe1011a71cd8e78d248e072fb7d60231 inherit pub_methods_classsigc_1_1volatile__mem__functor5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a98e43ac4bafb96958bbbf658154794d0 inherit pub_methods_classsigc_1_1volatile__mem__functor5"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#a98e43ac4bafb96958bbbf658154794d0">volatile_mem_functor5</a> (<a class="el" href="classsigc_1_1volatile__mem__functor5.html#a43ce719034586bbd097c823376c288ef">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a98e43ac4bafb96958bbbf658154794d0 inherit pub_methods_classsigc_1_1volatile__mem__functor5"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1volatile__mem__functor5.html" title="volatile_mem_functor5 wraps volatile methods with 5 argument(s).">volatile_mem_functor5</a> object that wraps the passed method. <a href="classsigc_1_1volatile__mem__functor5.html#a98e43ac4bafb96958bbbf658154794d0">More...</a><br /></td></tr>
+<tr class="separator:a98e43ac4bafb96958bbbf658154794d0 inherit pub_methods_classsigc_1_1volatile__mem__functor5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4a4b9b8ce1ce396ed9fa355ed56cf7b2 inherit pub_methods_classsigc_1_1volatile__mem__functor5"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#a4a4b9b8ce1ce396ed9fa355ed56cf7b2">operator()</a> (T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:a4a4b9b8ce1ce396ed9fa355ed56cf7b2 inherit pub_methods_classsigc_1_1volatile__mem__functor5"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor5.html#a4a4b9b8ce1ce396ed9fa355ed56cf7b2">More...</a><br /></td></tr>
+<tr class="separator:a4a4b9b8ce1ce396ed9fa355ed56cf7b2 inherit pub_methods_classsigc_1_1volatile__mem__functor5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab6449c487e42fc9810c0f8d5a6cc243f inherit pub_methods_classsigc_1_1volatile__mem__functor5"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#ab6449c487e42fc9810c0f8d5a6cc243f">operator()</a> (T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:ab6449c487e42fc9810c0f8d5a6cc243f inherit pub_methods_classsigc_1_1volatile__mem__functor5"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor5.html#ab6449c487e42fc9810c0f8d5a6cc243f">More...</a><br /></td></tr>
+<tr class="separator:ab6449c487e42fc9810c0f8d5a6cc243f inherit pub_methods_classsigc_1_1volatile__mem__functor5"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:ae17c42b74b72c74f3a7e4d5faadaa761"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__limit__reference.html">volatile_limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#ae17c42b74b72c74f3a7e4d5faadaa761">obj_</a></td></tr>
+<tr class="separator:ae17c42b74b72c74f3a7e4d5faadaa761"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1volatile__mem__functor5"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1volatile__mem__functor5')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1volatile__mem__functor5.html">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td></tr>
+<tr class="memitem:a01d38ddf6e713a47199fba85fd5a8092 inherit pro_attribs_classsigc_1_1volatile__mem__functor5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#a43ce719034586bbd097c823376c288ef">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#a01d38ddf6e713a47199fba85fd5a8092">func_ptr_</a></td></tr>
+<tr class="separator:a01d38ddf6e713a47199fba85fd5a8092 inherit pro_attribs_classsigc_1_1volatile__mem__functor5"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5><br />
+class sigc::bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html" title="bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance.">bound_volatile_mem_functor5</a> encapsulates a volatile method with 5 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html" title="bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance.">bound_volatile_mem_functor5</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#aaf0765f195ee2efef0536dfb854af9e4" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#aaf0765f195ee2efef0536dfb854af9e4" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#aaf0765f195ee2efef0536dfb854af9e4" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#aaf0765f195ee2efef0536dfb854af9e4" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#aaf0765f195ee2efef0536dfb854af9e4" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#aaf0765f195ee2efef0536dfb854af9e4" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a1561f499bd4d950fd36ee43ee60db585"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1561f499bd4d950fd36ee43ee60db585">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">sigc::bound_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#a1561f499bd4d950fd36ee43ee60db585">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="af5e4db24b5ba51d92746aa3fee080d49"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af5e4db24b5ba51d92746aa3fee080d49">◆ </a></span>bound_volatile_mem_functor5() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">sigc::bound_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">bound_volatile_mem_functor5</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#a1561f499bd4d950fd36ee43ee60db585">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html" title="bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance.">bound_volatile_mem_functor5</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000183">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#aaf0765f195ee2efef0536dfb854af9e4" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a01734765e6a89bd0ab89063f130541e3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a01734765e6a89bd0ab89063f130541e3">◆ </a></span>bound_volatile_mem_functor5() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">sigc::bound_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">bound_volatile_mem_functor5</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#a1561f499bd4d950fd36ee43ee60db585">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html" title="bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance.">bound_volatile_mem_functor5</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#aaf0765f195ee2efef0536dfb854af9e4" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="aaf0765f195ee2efef0536dfb854af9e4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aaf0765f195ee2efef0536dfb854af9e4">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">sigc::bound_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="ae17c42b74b72c74f3a7e4d5faadaa761"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae17c42b74b72c74f3a7e4d5faadaa761">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__limit__reference.html">volatile_limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">sigc::bound_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >" name="sigc::bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >">
+<area shape="rect" id="node1" title="bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance." alt="" coords="431,5,628,76"/>
+<area shape="rect" id="node2" href="$classsigc_1_1volatile__mem__functor5.html" title="volatile_mem_functor5 wraps volatile methods with 5 argument(s)." alt="" coords="193,5,383,76"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,27,145,54"/>
+</map>
--- /dev/null
+96cfeac66362966d00e0254dca8df909
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">bound_volatile_mem_functor6</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">sigc::bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#acb8a7befd300496343cf46d8520db04f">bound_volatile_mem_functor6</a>(T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">sigc::bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#af79be68e9cb6c772f6d6e817bffe9656">bound_volatile_mem_functor6</a>(T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">sigc::bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#aa64e5accf2702a06bffb6ed68fd95022">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor6.html">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#a6eeca5f695bff3c3302e4cf7d222a73d">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">sigc::bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#a64c4455bc351be0f2b42dc28b03baeb9">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">sigc::bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#aa8aa3006bba7344c630f6f8adb3507d5">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">sigc::bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#a00320a319413753f756304a8db0fbf51">sigc::volatile_mem_functor6::operator()</a>(T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor6.html">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#a2fdda8079c742fd0366c3fc057ea45e5">sigc::volatile_mem_functor6::operator()</a>(T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor6.html">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#a1ce192c145ec5af4c826ccb2619cf002">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor6.html">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#a782bbd4bff8bd939a008ceb9e0511bae">volatile_mem_functor6</a>()</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor6.html">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#a55c428dacaaff7f5dcd48ec02b53ed60">volatile_mem_functor6</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor6.html">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">bound_volatile_mem_functor6</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__volatile__mem__functor6-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html" title="bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance.">bound_volatile_mem_functor6</a> encapsulates a volatile method with 6 arguments and an object instance.
+ <a href="classsigc_1_1bound__volatile__mem__functor6.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__volatile__mem__functor6__inherit__graph.png" border="0" usemap="#asigc_1_1bound__volatile__mem__functor6_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__volatile__mem__functor6_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_01_4_inherit__map" id="asigc_1_1bound__volatile__mem__functor6_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_01_4_inherit__map">
+<area shape="rect" title="bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance." alt="" coords="420,5,617,91"/>
+<area shape="rect" href="classsigc_1_1volatile__mem__functor6.html" title="volatile_mem_functor6 wraps volatile methods with 6 argument(s)." alt="" coords="193,5,372,91"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,35,145,61"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a6eeca5f695bff3c3302e4cf7d222a73d"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#a6eeca5f695bff3c3302e4cf7d222a73d">function_type</a></td></tr>
+<tr class="separator:a6eeca5f695bff3c3302e4cf7d222a73d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1volatile__mem__functor6"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1volatile__mem__functor6')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1volatile__mem__functor6.html">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td></tr>
+<tr class="memitem:a67b3a13a2f595360ff6f78cb96efe9d1 inherit pub_types_classsigc_1_1volatile__mem__functor6"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#a67b3a13a2f595360ff6f78cb96efe9d1">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile</td></tr>
+<tr class="separator:a67b3a13a2f595360ff6f78cb96efe9d1 inherit pub_types_classsigc_1_1volatile__mem__functor6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1ce192c145ec5af4c826ccb2619cf002 inherit pub_types_classsigc_1_1volatile__mem__functor6"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#a1ce192c145ec5af4c826ccb2619cf002">result_type</a></td></tr>
+<tr class="separator:a1ce192c145ec5af4c826ccb2619cf002 inherit pub_types_classsigc_1_1volatile__mem__functor6"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:af79be68e9cb6c772f6d6e817bffe9656"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#af79be68e9cb6c772f6d6e817bffe9656">bound_volatile_mem_functor6</a> (T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#a6eeca5f695bff3c3302e4cf7d222a73d">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:af79be68e9cb6c772f6d6e817bffe9656"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html" title="bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance.">bound_volatile_mem_functor6</a> object that wraps the passed method. <a href="classsigc_1_1bound__volatile__mem__functor6.html#af79be68e9cb6c772f6d6e817bffe9656">More...</a><br /></td></tr>
+<tr class="separator:af79be68e9cb6c772f6d6e817bffe9656"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acb8a7befd300496343cf46d8520db04f"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#acb8a7befd300496343cf46d8520db04f">bound_volatile_mem_functor6</a> (T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#a6eeca5f695bff3c3302e4cf7d222a73d">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:acb8a7befd300496343cf46d8520db04f"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html" title="bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance.">bound_volatile_mem_functor6</a> object that wraps the passed method. <a href="classsigc_1_1bound__volatile__mem__functor6.html#acb8a7befd300496343cf46d8520db04f">More...</a><br /></td></tr>
+<tr class="separator:acb8a7befd300496343cf46d8520db04f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa8aa3006bba7344c630f6f8adb3507d5"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#aa8aa3006bba7344c630f6f8adb3507d5">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:aa8aa3006bba7344c630f6f8adb3507d5"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__volatile__mem__functor6.html#aa8aa3006bba7344c630f6f8adb3507d5">More...</a><br /></td></tr>
+<tr class="separator:aa8aa3006bba7344c630f6f8adb3507d5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1volatile__mem__functor6"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1volatile__mem__functor6')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1volatile__mem__functor6.html">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td></tr>
+<tr class="memitem:a782bbd4bff8bd939a008ceb9e0511bae inherit pub_methods_classsigc_1_1volatile__mem__functor6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#a782bbd4bff8bd939a008ceb9e0511bae">volatile_mem_functor6</a> ()</td></tr>
+<tr class="memdesc:a782bbd4bff8bd939a008ceb9e0511bae inherit pub_methods_classsigc_1_1volatile__mem__functor6"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1volatile__mem__functor6.html#a782bbd4bff8bd939a008ceb9e0511bae">More...</a><br /></td></tr>
+<tr class="separator:a782bbd4bff8bd939a008ceb9e0511bae inherit pub_methods_classsigc_1_1volatile__mem__functor6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a55c428dacaaff7f5dcd48ec02b53ed60 inherit pub_methods_classsigc_1_1volatile__mem__functor6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#a55c428dacaaff7f5dcd48ec02b53ed60">volatile_mem_functor6</a> (<a class="el" href="classsigc_1_1volatile__mem__functor6.html#a67b3a13a2f595360ff6f78cb96efe9d1">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a55c428dacaaff7f5dcd48ec02b53ed60 inherit pub_methods_classsigc_1_1volatile__mem__functor6"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1volatile__mem__functor6.html" title="volatile_mem_functor6 wraps volatile methods with 6 argument(s).">volatile_mem_functor6</a> object that wraps the passed method. <a href="classsigc_1_1volatile__mem__functor6.html#a55c428dacaaff7f5dcd48ec02b53ed60">More...</a><br /></td></tr>
+<tr class="separator:a55c428dacaaff7f5dcd48ec02b53ed60 inherit pub_methods_classsigc_1_1volatile__mem__functor6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2fdda8079c742fd0366c3fc057ea45e5 inherit pub_methods_classsigc_1_1volatile__mem__functor6"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#a2fdda8079c742fd0366c3fc057ea45e5">operator()</a> (T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:a2fdda8079c742fd0366c3fc057ea45e5 inherit pub_methods_classsigc_1_1volatile__mem__functor6"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor6.html#a2fdda8079c742fd0366c3fc057ea45e5">More...</a><br /></td></tr>
+<tr class="separator:a2fdda8079c742fd0366c3fc057ea45e5 inherit pub_methods_classsigc_1_1volatile__mem__functor6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a00320a319413753f756304a8db0fbf51 inherit pub_methods_classsigc_1_1volatile__mem__functor6"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#a00320a319413753f756304a8db0fbf51">operator()</a> (T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:a00320a319413753f756304a8db0fbf51 inherit pub_methods_classsigc_1_1volatile__mem__functor6"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor6.html#a00320a319413753f756304a8db0fbf51">More...</a><br /></td></tr>
+<tr class="separator:a00320a319413753f756304a8db0fbf51 inherit pub_methods_classsigc_1_1volatile__mem__functor6"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:a64c4455bc351be0f2b42dc28b03baeb9"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__limit__reference.html">volatile_limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#a64c4455bc351be0f2b42dc28b03baeb9">obj_</a></td></tr>
+<tr class="separator:a64c4455bc351be0f2b42dc28b03baeb9"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1volatile__mem__functor6"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1volatile__mem__functor6')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1volatile__mem__functor6.html">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td></tr>
+<tr class="memitem:aa64e5accf2702a06bffb6ed68fd95022 inherit pro_attribs_classsigc_1_1volatile__mem__functor6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#a67b3a13a2f595360ff6f78cb96efe9d1">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#aa64e5accf2702a06bffb6ed68fd95022">func_ptr_</a></td></tr>
+<tr class="separator:aa64e5accf2702a06bffb6ed68fd95022 inherit pro_attribs_classsigc_1_1volatile__mem__functor6"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6><br />
+class sigc::bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html" title="bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance.">bound_volatile_mem_functor6</a> encapsulates a volatile method with 6 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html" title="bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance.">bound_volatile_mem_functor6</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#aa8aa3006bba7344c630f6f8adb3507d5" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#aa8aa3006bba7344c630f6f8adb3507d5" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#aa8aa3006bba7344c630f6f8adb3507d5" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#aa8aa3006bba7344c630f6f8adb3507d5" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#aa8aa3006bba7344c630f6f8adb3507d5" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg6</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#aa8aa3006bba7344c630f6f8adb3507d5" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#aa8aa3006bba7344c630f6f8adb3507d5" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a6eeca5f695bff3c3302e4cf7d222a73d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a6eeca5f695bff3c3302e4cf7d222a73d">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">sigc::bound_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#a6eeca5f695bff3c3302e4cf7d222a73d">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="acb8a7befd300496343cf46d8520db04f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#acb8a7befd300496343cf46d8520db04f">◆ </a></span>bound_volatile_mem_functor6() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">sigc::bound_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">bound_volatile_mem_functor6</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#a6eeca5f695bff3c3302e4cf7d222a73d">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html" title="bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance.">bound_volatile_mem_functor6</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000184">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#aa8aa3006bba7344c630f6f8adb3507d5" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="af79be68e9cb6c772f6d6e817bffe9656"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af79be68e9cb6c772f6d6e817bffe9656">◆ </a></span>bound_volatile_mem_functor6() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">sigc::bound_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">bound_volatile_mem_functor6</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#a6eeca5f695bff3c3302e4cf7d222a73d">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html" title="bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance.">bound_volatile_mem_functor6</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#aa8aa3006bba7344c630f6f8adb3507d5" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="aa8aa3006bba7344c630f6f8adb3507d5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa8aa3006bba7344c630f6f8adb3507d5">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">sigc::bound_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a64c4455bc351be0f2b42dc28b03baeb9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a64c4455bc351be0f2b42dc28b03baeb9">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__limit__reference.html">volatile_limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">sigc::bound_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >" name="sigc::bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >">
+<area shape="rect" id="node1" title="bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance." alt="" coords="420,5,617,91"/>
+<area shape="rect" id="node2" href="$classsigc_1_1volatile__mem__functor6.html" title="volatile_mem_functor6 wraps volatile methods with 6 argument(s)." alt="" coords="193,5,372,91"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,35,145,61"/>
+</map>
--- /dev/null
+d8f485b8af116d0eb6baa82684e40411
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">bound_volatile_mem_functor7</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">sigc::bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#a18f28191685aa86228328e7016b5c803">bound_volatile_mem_functor7</a>(T_obj * _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">sigc::bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#a3109683023c9e82a586660399b12769e">bound_volatile_mem_functor7</a>(T_obj & _A_obj, function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">sigc::bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#ac74b72d519805a654529347e4c638e6f">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor7.html">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#afce6246f9f2828a7185b3c696435d70a">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">sigc::bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#a32b6c9b9aaa1e750217fc1f9d9e4b2df">obj_</a></td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">sigc::bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#ad1ab1d5cf45600c5369a0a119a5a89ad">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">sigc::bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#ae587c12caf1c68886fbf001b2c8acc03">sigc::volatile_mem_functor7::operator()</a>(T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor7.html">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#a05ed4811582f583a1a1e11b1a8951a21">sigc::volatile_mem_functor7::operator()</a>(T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor7.html">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#a4762374376dcb7b11c77372edab78823">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor7.html">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#a07834a50703bf92aad9bc167fa256d24">volatile_mem_functor7</a>()</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor7.html">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#a809146646d2dd726a385344f455402e4">volatile_mem_functor7</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor7.html">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">bound_volatile_mem_functor7</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1bound__volatile__mem__functor7-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html" title="bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance.">bound_volatile_mem_functor7</a> encapsulates a volatile method with 7 arguments and an object instance.
+ <a href="classsigc_1_1bound__volatile__mem__functor7.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1bound__volatile__mem__functor7__inherit__graph.png" border="0" usemap="#asigc_1_1bound__volatile__mem__functor7_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bound__volatile__mem__functor7_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map" id="asigc_1_1bound__volatile__mem__functor7_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map">
+<area shape="rect" title="bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance." alt="" coords="420,5,617,91"/>
+<area shape="rect" href="classsigc_1_1volatile__mem__functor7.html" title="volatile_mem_functor7 wraps volatile methods with 7 argument(s)." alt="" coords="193,5,372,91"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,35,145,61"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:afce6246f9f2828a7185b3c696435d70a"><td class="memItemLeft" align="right" valign="top">typedef base_type_::function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#afce6246f9f2828a7185b3c696435d70a">function_type</a></td></tr>
+<tr class="separator:afce6246f9f2828a7185b3c696435d70a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1volatile__mem__functor7"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1volatile__mem__functor7')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1volatile__mem__functor7.html">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td></tr>
+<tr class="memitem:a4ee701fd029c3b7f2f3a3af1aef428a0 inherit pub_types_classsigc_1_1volatile__mem__functor7"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#a4ee701fd029c3b7f2f3a3af1aef428a0">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile</td></tr>
+<tr class="separator:a4ee701fd029c3b7f2f3a3af1aef428a0 inherit pub_types_classsigc_1_1volatile__mem__functor7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4762374376dcb7b11c77372edab78823 inherit pub_types_classsigc_1_1volatile__mem__functor7"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#a4762374376dcb7b11c77372edab78823">result_type</a></td></tr>
+<tr class="separator:a4762374376dcb7b11c77372edab78823 inherit pub_types_classsigc_1_1volatile__mem__functor7"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a3109683023c9e82a586660399b12769e"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#a3109683023c9e82a586660399b12769e">bound_volatile_mem_functor7</a> (T_obj & _A_obj, <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#afce6246f9f2828a7185b3c696435d70a">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a3109683023c9e82a586660399b12769e"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html" title="bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance.">bound_volatile_mem_functor7</a> object that wraps the passed method. <a href="classsigc_1_1bound__volatile__mem__functor7.html#a3109683023c9e82a586660399b12769e">More...</a><br /></td></tr>
+<tr class="separator:a3109683023c9e82a586660399b12769e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a18f28191685aa86228328e7016b5c803"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#a18f28191685aa86228328e7016b5c803">bound_volatile_mem_functor7</a> (T_obj * _A_obj, <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#afce6246f9f2828a7185b3c696435d70a">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a18f28191685aa86228328e7016b5c803"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html" title="bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance.">bound_volatile_mem_functor7</a> object that wraps the passed method. <a href="classsigc_1_1bound__volatile__mem__functor7.html#a18f28191685aa86228328e7016b5c803">More...</a><br /></td></tr>
+<tr class="separator:a18f28191685aa86228328e7016b5c803"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1ab1d5cf45600c5369a0a119a5a89ad"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#ad1ab1d5cf45600c5369a0a119a5a89ad">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:ad1ab1d5cf45600c5369a0a119a5a89ad"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the stored instance. <a href="classsigc_1_1bound__volatile__mem__functor7.html#ad1ab1d5cf45600c5369a0a119a5a89ad">More...</a><br /></td></tr>
+<tr class="separator:ad1ab1d5cf45600c5369a0a119a5a89ad"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1volatile__mem__functor7"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1volatile__mem__functor7')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1volatile__mem__functor7.html">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td></tr>
+<tr class="memitem:a07834a50703bf92aad9bc167fa256d24 inherit pub_methods_classsigc_1_1volatile__mem__functor7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#a07834a50703bf92aad9bc167fa256d24">volatile_mem_functor7</a> ()</td></tr>
+<tr class="memdesc:a07834a50703bf92aad9bc167fa256d24 inherit pub_methods_classsigc_1_1volatile__mem__functor7"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1volatile__mem__functor7.html#a07834a50703bf92aad9bc167fa256d24">More...</a><br /></td></tr>
+<tr class="separator:a07834a50703bf92aad9bc167fa256d24 inherit pub_methods_classsigc_1_1volatile__mem__functor7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a809146646d2dd726a385344f455402e4 inherit pub_methods_classsigc_1_1volatile__mem__functor7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#a809146646d2dd726a385344f455402e4">volatile_mem_functor7</a> (<a class="el" href="classsigc_1_1volatile__mem__functor7.html#a4ee701fd029c3b7f2f3a3af1aef428a0">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a809146646d2dd726a385344f455402e4 inherit pub_methods_classsigc_1_1volatile__mem__functor7"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1volatile__mem__functor7.html" title="volatile_mem_functor7 wraps volatile methods with 7 argument(s).">volatile_mem_functor7</a> object that wraps the passed method. <a href="classsigc_1_1volatile__mem__functor7.html#a809146646d2dd726a385344f455402e4">More...</a><br /></td></tr>
+<tr class="separator:a809146646d2dd726a385344f455402e4 inherit pub_methods_classsigc_1_1volatile__mem__functor7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a05ed4811582f583a1a1e11b1a8951a21 inherit pub_methods_classsigc_1_1volatile__mem__functor7"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#a05ed4811582f583a1a1e11b1a8951a21">operator()</a> (T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:a05ed4811582f583a1a1e11b1a8951a21 inherit pub_methods_classsigc_1_1volatile__mem__functor7"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor7.html#a05ed4811582f583a1a1e11b1a8951a21">More...</a><br /></td></tr>
+<tr class="separator:a05ed4811582f583a1a1e11b1a8951a21 inherit pub_methods_classsigc_1_1volatile__mem__functor7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae587c12caf1c68886fbf001b2c8acc03 inherit pub_methods_classsigc_1_1volatile__mem__functor7"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#ae587c12caf1c68886fbf001b2c8acc03">operator()</a> (T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:ae587c12caf1c68886fbf001b2c8acc03 inherit pub_methods_classsigc_1_1volatile__mem__functor7"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor7.html#ae587c12caf1c68886fbf001b2c8acc03">More...</a><br /></td></tr>
+<tr class="separator:ae587c12caf1c68886fbf001b2c8acc03 inherit pub_methods_classsigc_1_1volatile__mem__functor7"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:a32b6c9b9aaa1e750217fc1f9d9e4b2df"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__limit__reference.html">volatile_limit_reference</a>< T_obj > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#a32b6c9b9aaa1e750217fc1f9d9e4b2df">obj_</a></td></tr>
+<tr class="separator:a32b6c9b9aaa1e750217fc1f9d9e4b2df"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_attribs_classsigc_1_1volatile__mem__functor7"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classsigc_1_1volatile__mem__functor7')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="classsigc_1_1volatile__mem__functor7.html">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td></tr>
+<tr class="memitem:ac74b72d519805a654529347e4c638e6f inherit pro_attribs_classsigc_1_1volatile__mem__functor7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#a4ee701fd029c3b7f2f3a3af1aef428a0">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#ac74b72d519805a654529347e4c638e6f">func_ptr_</a></td></tr>
+<tr class="separator:ac74b72d519805a654529347e4c638e6f inherit pro_attribs_classsigc_1_1volatile__mem__functor7"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7><br />
+class sigc::bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></h3>
+
+<p><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html" title="bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance.">bound_volatile_mem_functor7</a> encapsulates a volatile method with 7 arguments and an object instance. </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html" title="bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance.">bound_volatile_mem_functor7</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#ad1ab1d5cf45600c5369a0a119a5a89ad" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#ad1ab1d5cf45600c5369a0a119a5a89ad" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#ad1ab1d5cf45600c5369a0a119a5a89ad" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#ad1ab1d5cf45600c5369a0a119a5a89ad" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#ad1ab1d5cf45600c5369a0a119a5a89ad" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg6</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#ad1ab1d5cf45600c5369a0a119a5a89ad" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_arg7</em> Argument type used in the definition of <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#ad1ab1d5cf45600c5369a0a119a5a89ad" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#ad1ab1d5cf45600c5369a0a119a5a89ad" title="Execute the wrapped method operating on the stored instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="afce6246f9f2828a7185b3c696435d70a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#afce6246f9f2828a7185b3c696435d70a">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef base_type_::function_type <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">sigc::bound_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#afce6246f9f2828a7185b3c696435d70a">function_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a18f28191685aa86228328e7016b5c803"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a18f28191685aa86228328e7016b5c803">◆ </a></span>bound_volatile_mem_functor7() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">sigc::bound_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">bound_volatile_mem_functor7</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#afce6246f9f2828a7185b3c696435d70a">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html" title="bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance.">bound_volatile_mem_functor7</a> object that wraps the passed method. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000185">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#ad1ab1d5cf45600c5369a0a119a5a89ad" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a3109683023c9e82a586660399b12769e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3109683023c9e82a586660399b12769e">◆ </a></span>bound_volatile_mem_functor7() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">sigc::bound_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">bound_volatile_mem_functor7</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#afce6246f9f2828a7185b3c696435d70a">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html" title="bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance.">bound_volatile_mem_functor7</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method will operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#ad1ab1d5cf45600c5369a0a119a5a89ad" title="Execute the wrapped method operating on the stored instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="ad1ab1d5cf45600c5369a0a119a5a89ad"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad1ab1d5cf45600c5369a0a119a5a89ad">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">sigc::bound_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > </td>
+ <td class="paramname"><em>_A_a7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the stored instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a7</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a32b6c9b9aaa1e750217fc1f9d9e4b2df"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a32b6c9b9aaa1e750217fc1f9d9e4b2df">◆ </a></span>obj_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__limit__reference.html">volatile_limit_reference</a><T_obj> <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">sigc::bound_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::obj_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >" name="sigc::bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >">
+<area shape="rect" id="node1" title="bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance." alt="" coords="420,5,617,91"/>
+<area shape="rect" id="node2" href="$classsigc_1_1volatile__mem__functor7.html" title="volatile_mem_functor7 wraps volatile methods with 7 argument(s)." alt="" coords="193,5,372,91"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,35,145,61"/>
+</map>
--- /dev/null
+18cc3f39db87359cb0eeb43ce93bec74
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1can__deduce__result__type__with__decltype.html">can_deduce_result_type_with_decltype</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::can_deduce_result_type_with_decltype< T_functor > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1can__deduce__result__type__with__decltype.html">sigc::can_deduce_result_type_with_decltype< T_functor ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1can__deduce__result__type__with__decltype.html#a3e390d22fe03a03bb34bb38bca1aea91">value</a></td><td class="entry"><a class="el" href="classsigc_1_1can__deduce__result__type__with__decltype.html">sigc::can_deduce_result_type_with_decltype< T_functor ></a></td><td class="entry"><span class="mlabel">static</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::can_deduce_result_type_with_decltype< T_functor > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1can__deduce__result__type__with__decltype.html">can_deduce_result_type_with_decltype</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#nested-classes">Classes</a> |
+<a href="#pub-static-attribs">Static Public Attributes</a> |
+<a href="classsigc_1_1can__deduce__result__type__with__decltype-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::can_deduce_result_type_with_decltype< T_functor > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Helper class, to determine if decltype() can deduce the result type of a functor.
+ <a href="classsigc_1_1can__deduce__result__type__with__decltype.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/functor_trait.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-static-attribs"></a>
+Static Public Attributes</h2></td></tr>
+<tr class="memitem:a3e390d22fe03a03bb34bb38bca1aea91"><td class="memItemLeft" align="right" valign="top">static const bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1can__deduce__result__type__with__decltype.html#a3e390d22fe03a03bb34bb38bca1aea91">value</a></td></tr>
+<tr class="separator:a3e390d22fe03a03bb34bb38bca1aea91"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<typename T_functor><br />
+class sigc::can_deduce_result_type_with_decltype< T_functor ></h3>
+
+<p>Helper class, to determine if decltype() can deduce the result type of a functor. </p>
+</div><h2 class="groupheader">Member Data Documentation</h2>
+<a id="a3e390d22fe03a03bb34bb38bca1aea91"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3e390d22fe03a03bb34bb38bca1aea91">◆ </a></span>value</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">const bool <a class="el" href="classsigc_1_1can__deduce__result__type__with__decltype.html">sigc::can_deduce_result_type_with_decltype</a>< T_functor >::value</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">static</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__limit__reference.html">const_limit_reference</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::const_limit_reference< T_type, I_derives_trackable > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1const__limit__reference.html">sigc::const_limit_reference< T_type, I_derives_trackable ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__limit__reference.html#acee8a4c09720730cd5f66696fd018b4c">const_limit_reference</a>(const T_type & _A_target)</td><td class="entry"><a class="el" href="classsigc_1_1const__limit__reference.html">sigc::const_limit_reference< T_type, I_derives_trackable ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__limit__reference.html#abb05a4234000dbf4a256b446d3ef580d">invoke</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1const__limit__reference.html">sigc::const_limit_reference< T_type, I_derives_trackable ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__limit__reference.html#aa7486303566b2a9a74e55561083ed3d9">visit</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1const__limit__reference.html">sigc::const_limit_reference< T_type, I_derives_trackable ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::const_limit_reference< T_type, I_derives_trackable > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__limit__reference.html">const_limit_reference</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1const__limit__reference-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::const_limit_reference< T_type, I_derives_trackable > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>A const_limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>, then <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each<>()</a> will "limit" itself to the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference instead of the derived reference.
+ <a href="classsigc_1_1const__limit__reference.html#details">More...</a></p>
+
+<p><code>#include <sigc++/limit_reference.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:acee8a4c09720730cd5f66696fd018b4c"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__limit__reference.html#acee8a4c09720730cd5f66696fd018b4c">const_limit_reference</a> (const T_type & _A_target)</td></tr>
+<tr class="memdesc:acee8a4c09720730cd5f66696fd018b4c"><td class="mdescLeft"> </td><td class="mdescRight">Constructor. <a href="classsigc_1_1const__limit__reference.html#acee8a4c09720730cd5f66696fd018b4c">More...</a><br /></td></tr>
+<tr class="separator:acee8a4c09720730cd5f66696fd018b4c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abb05a4234000dbf4a256b446d3ef580d"><td class="memItemLeft" align="right" valign="top">const T_type & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__limit__reference.html#abb05a4234000dbf4a256b446d3ef580d">invoke</a> () const</td></tr>
+<tr class="memdesc:abb05a4234000dbf4a256b446d3ef580d"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the reference. <a href="classsigc_1_1const__limit__reference.html#abb05a4234000dbf4a256b446d3ef580d">More...</a><br /></td></tr>
+<tr class="separator:abb05a4234000dbf4a256b446d3ef580d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7486303566b2a9a74e55561083ed3d9"><td class="memItemLeft" align="right" valign="top">const T_type & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__limit__reference.html#aa7486303566b2a9a74e55561083ed3d9">visit</a> () const</td></tr>
+<tr class="memdesc:aa7486303566b2a9a74e55561083ed3d9"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the entity to visit for <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each()</a>. <a href="classsigc_1_1const__limit__reference.html#aa7486303566b2a9a74e55561083ed3d9">More...</a><br /></td></tr>
+<tr class="separator:aa7486303566b2a9a74e55561083ed3d9"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_type, bool I_derives_trackable = std::is_base_of<trackable, T_type>::value><br />
+class sigc::const_limit_reference< T_type, I_derives_trackable ></h3>
+
+<p>A const_limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>, then <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each<>()</a> will "limit" itself to the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference instead of the derived reference. </p>
+<p>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.</p>
+<p>If Foo inherits from trackable then both the derived reference and the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference are stored, so we can later retrieve the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference without doing an implicit conversion. To retrieve the derived reference (so that you invoke methods or members of it), use <a class="el" href="classsigc_1_1const__limit__reference.html#abb05a4234000dbf4a256b446d3ef580d" title="Retrieve the reference.">invoke()</a>. To retrieve the trackable reference (so that you can call <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each()</a> on it), you use <a class="el" href="classsigc_1_1const__limit__reference.html#aa7486303566b2a9a74e55561083ed3d9" title="Retrieve the entity to visit for visit_each().">visit()</a>.</p>
+<p>If Foo does not inherit from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> then <a class="el" href="classsigc_1_1const__limit__reference.html#abb05a4234000dbf4a256b446d3ef580d" title="Retrieve the reference.">invoke()</a> and <a class="el" href="classsigc_1_1const__limit__reference.html#aa7486303566b2a9a74e55561083ed3d9" title="Retrieve the entity to visit for visit_each().">visit()</a> just return the derived reference.</p>
+<p>This is used for bound (<a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">sigc::bind</a>) slot parameters (via <a class="el" href="classsigc_1_1bound__argument.html" title="A bound_argument<Foo> object stores a bound (for instance, with sigc::bind(), or sigc::bind_return())...">bound_argument</a>), bound return values, and, with <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a>, the reference to the handling object.</p>
+<ul>
+<li><em>T_type</em> The type of the reference. </li>
+</ul>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="acee8a4c09720730cd5f66696fd018b4c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#acee8a4c09720730cd5f66696fd018b4c">◆ </a></span>const_limit_reference()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type , bool I_derives_trackable = std::is_base_of<trackable, T_type>::value> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__limit__reference.html">sigc::const_limit_reference</a>< T_type, I_derives_trackable >::<a class="el" href="classsigc_1_1const__limit__reference.html">const_limit_reference</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_type & </td>
+ <td class="paramname"><em>_A_target</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_target</td><td>The reference to limit. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="abb05a4234000dbf4a256b446d3ef580d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abb05a4234000dbf4a256b446d3ef580d">◆ </a></span>invoke()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type , bool I_derives_trackable = std::is_base_of<trackable, T_type>::value> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">const T_type& <a class="el" href="classsigc_1_1const__limit__reference.html">sigc::const_limit_reference</a>< T_type, I_derives_trackable >::invoke </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Retrieve the reference. </p>
+<p>This is always a reference to the derived instance. </p><dl class="section return"><dt>Returns</dt><dd>The reference. </dd></dl>
+
+</div>
+</div>
+<a id="aa7486303566b2a9a74e55561083ed3d9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa7486303566b2a9a74e55561083ed3d9">◆ </a></span>visit()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type , bool I_derives_trackable = std::is_base_of<trackable, T_type>::value> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">const T_type& <a class="el" href="classsigc_1_1const__limit__reference.html">sigc::const_limit_reference</a>< T_type, I_derives_trackable >::visit </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Retrieve the entity to visit for <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each()</a>. </p>
+<p>Depending on the template specialization, this is either a derived reference, or <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>& if T_type derives from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>. </p><dl class="section return"><dt>Returns</dt><dd>The reference. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html">const_limit_reference< T_type, true ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::const_limit_reference< T_type, true > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html">sigc::const_limit_reference< T_type, true ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html#a68f1337800c19036c81512e76e0dd6cd">const_limit_reference</a>(const T_type & _A_target)</td><td class="entry"><a class="el" href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html">sigc::const_limit_reference< T_type, true ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html#a694136bfdbcc64717181ea2cc4714fa3">invoke</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html">sigc::const_limit_reference< T_type, true ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html#abe87b8e67b8a26658a5d6f45b036721a">visit</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html">sigc::const_limit_reference< T_type, true ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::const_limit_reference< T_type, true > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html">const_limit_reference< T_type, true ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::const_limit_reference< T_type, true > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1const__limit__reference.html" title="A const_limit_reference<Foo> object stores a reference (Foo&), but make sure that,...">const_limit_reference</a> object for a class that derives from trackable.
+ <a href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/limit_reference.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a68f1337800c19036c81512e76e0dd6cd"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html#a68f1337800c19036c81512e76e0dd6cd">const_limit_reference</a> (const T_type & _A_target)</td></tr>
+<tr class="memdesc:a68f1337800c19036c81512e76e0dd6cd"><td class="mdescLeft"> </td><td class="mdescRight">Constructor. <a href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html#a68f1337800c19036c81512e76e0dd6cd">More...</a><br /></td></tr>
+<tr class="separator:a68f1337800c19036c81512e76e0dd6cd"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a694136bfdbcc64717181ea2cc4714fa3"><td class="memItemLeft" align="right" valign="top">const T_type & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html#a694136bfdbcc64717181ea2cc4714fa3">invoke</a> () const</td></tr>
+<tr class="memdesc:a694136bfdbcc64717181ea2cc4714fa3"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the reference. <a href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html#a694136bfdbcc64717181ea2cc4714fa3">More...</a><br /></td></tr>
+<tr class="separator:a694136bfdbcc64717181ea2cc4714fa3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abe87b8e67b8a26658a5d6f45b036721a"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html#abe87b8e67b8a26658a5d6f45b036721a">visit</a> () const</td></tr>
+<tr class="memdesc:abe87b8e67b8a26658a5d6f45b036721a"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the entity to visit for <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each()</a>. <a href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html#abe87b8e67b8a26658a5d6f45b036721a">More...</a><br /></td></tr>
+<tr class="separator:abe87b8e67b8a26658a5d6f45b036721a"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_type><br />
+class sigc::const_limit_reference< T_type, true ></h3>
+
+<p><a class="el" href="classsigc_1_1const__limit__reference.html" title="A const_limit_reference<Foo> object stores a reference (Foo&), but make sure that,...">const_limit_reference</a> object for a class that derives from trackable. </p>
+<ul>
+<li><em>T_type</em> The type of the reference. </li>
+</ul>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a68f1337800c19036c81512e76e0dd6cd"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a68f1337800c19036c81512e76e0dd6cd">◆ </a></span>const_limit_reference()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__limit__reference.html">sigc::const_limit_reference</a>< T_type, true >::<a class="el" href="classsigc_1_1const__limit__reference.html">const_limit_reference</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_type & </td>
+ <td class="paramname"><em>_A_target</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_target</td><td>The reference to limit. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a694136bfdbcc64717181ea2cc4714fa3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a694136bfdbcc64717181ea2cc4714fa3">◆ </a></span>invoke()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">const T_type& <a class="el" href="classsigc_1_1const__limit__reference.html">sigc::const_limit_reference</a>< T_type, true >::invoke </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Retrieve the reference. </p>
+<p>This is always a reference to the derived instance. </p><dl class="section return"><dt>Returns</dt><dd>The reference. </dd></dl>
+
+</div>
+</div>
+<a id="abe87b8e67b8a26658a5d6f45b036721a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abe87b8e67b8a26658a5d6f45b036721a">◆ </a></span>visit()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">const <a class="el" href="structsigc_1_1trackable.html">trackable</a>& <a class="el" href="classsigc_1_1const__limit__reference.html">sigc::const_limit_reference</a>< T_type, true >::visit </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Retrieve the entity to visit for <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each()</a>. </p>
+<p>Depending on the template specialization, this is either a derived reference, or <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>& if T_type derives from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>. </p><dl class="section return"><dt>Returns</dt><dd>The reference. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__mem__functor0.html">const_mem_functor0</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::const_mem_functor0< T_return, T_obj > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1const__mem__functor0.html">sigc::const_mem_functor0< T_return, T_obj ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor0.html#a49bba4c8045b8b6933b8f5a854ac98d6">const_mem_functor0</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor0.html">sigc::const_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor0.html#a27895e58972642453f7b853f25a66f42">const_mem_functor0</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor0.html">sigc::const_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor0.html#a215359b20450c2afe93496826ac45c1d">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor0.html">sigc::const_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor0.html#a5b768319ee81e2aa9e96a900e5e64996">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor0.html">sigc::const_mem_functor0< T_return, T_obj ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor0.html#abcc08c39943577648dac107692e5b34a">operator()</a>(const T_obj * _A_obj) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor0.html">sigc::const_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor0.html#ac388853f99f074e549c8784d1a38f46b">operator()</a>(const T_obj & _A_obj) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor0.html">sigc::const_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor0.html#a553cd4d85524b5deea445b67773527bf">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor0.html">sigc::const_mem_functor0< T_return, T_obj ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::const_mem_functor0< T_return, T_obj > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__mem__functor0.html">const_mem_functor0</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1const__mem__functor0-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::const_mem_functor0< T_return, T_obj > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1const__mem__functor0.html" title="const_mem_functor0 wraps const methods with 0 argument(s).">const_mem_functor0</a> wraps const methods with 0 argument(s).
+ <a href="classsigc_1_1const__mem__functor0.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::const_mem_functor0< T_return, T_obj >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1const__mem__functor0__inherit__graph.png" border="0" usemap="#asigc_1_1const__mem__functor0_3_01T__return_00_01T__obj_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1const__mem__functor0_3_01T__return_00_01T__obj_01_4_inherit__map" id="asigc_1_1const__mem__functor0_3_01T__return_00_01T__obj_01_4_inherit__map">
+<area shape="rect" title="const_mem_functor0 wraps const methods with 0 argument(s)." alt="" coords="5,80,199,121"/>
+<area shape="rect" href="classsigc_1_1bound__const__mem__functor0.html" title="bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance." alt="" coords="13,169,191,225"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="32,5,172,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a5b768319ee81e2aa9e96a900e5e64996"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor0.html#a5b768319ee81e2aa9e96a900e5e64996">function_type</a>) () const</td></tr>
+<tr class="separator:a5b768319ee81e2aa9e96a900e5e64996"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a553cd4d85524b5deea445b67773527bf"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor0.html#a553cd4d85524b5deea445b67773527bf">result_type</a></td></tr>
+<tr class="separator:a553cd4d85524b5deea445b67773527bf"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a49bba4c8045b8b6933b8f5a854ac98d6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor0.html#a49bba4c8045b8b6933b8f5a854ac98d6">const_mem_functor0</a> ()</td></tr>
+<tr class="memdesc:a49bba4c8045b8b6933b8f5a854ac98d6"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__mem__functor0.html#a49bba4c8045b8b6933b8f5a854ac98d6">More...</a><br /></td></tr>
+<tr class="separator:a49bba4c8045b8b6933b8f5a854ac98d6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a27895e58972642453f7b853f25a66f42"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor0.html#a27895e58972642453f7b853f25a66f42">const_mem_functor0</a> (<a class="el" href="classsigc_1_1const__mem__functor0.html#a5b768319ee81e2aa9e96a900e5e64996">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a27895e58972642453f7b853f25a66f42"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__mem__functor0.html" title="const_mem_functor0 wraps const methods with 0 argument(s).">const_mem_functor0</a> object that wraps the passed method. <a href="classsigc_1_1const__mem__functor0.html#a27895e58972642453f7b853f25a66f42">More...</a><br /></td></tr>
+<tr class="separator:a27895e58972642453f7b853f25a66f42"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac388853f99f074e549c8784d1a38f46b"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor0.html#ac388853f99f074e549c8784d1a38f46b">operator()</a> (const T_obj & _A_obj) const</td></tr>
+<tr class="memdesc:ac388853f99f074e549c8784d1a38f46b"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor0.html#ac388853f99f074e549c8784d1a38f46b">More...</a><br /></td></tr>
+<tr class="separator:ac388853f99f074e549c8784d1a38f46b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abcc08c39943577648dac107692e5b34a"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor0.html#abcc08c39943577648dac107692e5b34a">operator()</a> (const T_obj * _A_obj) const</td></tr>
+<tr class="memdesc:abcc08c39943577648dac107692e5b34a"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor0.html#abcc08c39943577648dac107692e5b34a">More...</a><br /></td></tr>
+<tr class="separator:abcc08c39943577648dac107692e5b34a"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:a215359b20450c2afe93496826ac45c1d"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor0.html#a5b768319ee81e2aa9e96a900e5e64996">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor0.html#a215359b20450c2afe93496826ac45c1d">func_ptr_</a></td></tr>
+<tr class="separator:a215359b20450c2afe93496826ac45c1d"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj><br />
+class sigc::const_mem_functor0< T_return, T_obj ></h3>
+
+<p><a class="el" href="classsigc_1_1const__mem__functor0.html" title="const_mem_functor0 wraps const methods with 0 argument(s).">const_mem_functor0</a> wraps const methods with 0 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1const__mem__functor0.html" title="const_mem_functor0 wraps const methods with 0 argument(s).">const_mem_functor0</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1const__mem__functor0.html#abcc08c39943577648dac107692e5b34a" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a5b768319ee81e2aa9e96a900e5e64996"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5b768319ee81e2aa9e96a900e5e64996">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1const__mem__functor0.html">sigc::const_mem_functor0</a>< T_return, T_obj >::function_type) () const</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a553cd4d85524b5deea445b67773527bf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a553cd4d85524b5deea445b67773527bf">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1const__mem__functor0.html">sigc::const_mem_functor0</a>< T_return, T_obj >::<a class="el" href="classsigc_1_1const__mem__functor0.html#a553cd4d85524b5deea445b67773527bf">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a49bba4c8045b8b6933b8f5a854ac98d6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a49bba4c8045b8b6933b8f5a854ac98d6">◆ </a></span>const_mem_functor0() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor0.html">sigc::const_mem_functor0</a>< T_return, T_obj >::<a class="el" href="classsigc_1_1const__mem__functor0.html">const_mem_functor0</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="a27895e58972642453f7b853f25a66f42"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a27895e58972642453f7b853f25a66f42">◆ </a></span>const_mem_functor0() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor0.html">sigc::const_mem_functor0</a>< T_return, T_obj >::<a class="el" href="classsigc_1_1const__mem__functor0.html">const_mem_functor0</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1const__mem__functor0.html#a5b768319ee81e2aa9e96a900e5e64996">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1const__mem__functor0.html" title="const_mem_functor0 wraps const methods with 0 argument(s).">const_mem_functor0</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1const__mem__functor0.html#abcc08c39943577648dac107692e5b34a" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="ac388853f99f074e549c8784d1a38f46b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac388853f99f074e549c8784d1a38f46b">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__mem__functor0.html">sigc::const_mem_functor0</a>< T_return, T_obj >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="abcc08c39943577648dac107692e5b34a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abcc08c39943577648dac107692e5b34a">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__mem__functor0.html">sigc::const_mem_functor0</a>< T_return, T_obj >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000138">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a215359b20450c2afe93496826ac45c1d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a215359b20450c2afe93496826ac45c1d">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor0.html#a5b768319ee81e2aa9e96a900e5e64996">function_type</a> <a class="el" href="classsigc_1_1const__mem__functor0.html">sigc::const_mem_functor0</a>< T_return, T_obj >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::const_mem_functor0< T_return, T_obj >" name="sigc::const_mem_functor0< T_return, T_obj >">
+<area shape="rect" id="node1" title="const_mem_functor0 wraps const methods with 0 argument(s)." alt="" coords="5,80,199,121"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__const__mem__functor0.html" title="bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance." alt="" coords="13,169,191,225"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="32,5,172,32"/>
+</map>
--- /dev/null
+ff1e40ae3215a084ad0fb91dbef0bf6c
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__mem__functor1.html">const_mem_functor1</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::const_mem_functor1< T_return, T_obj, T_arg1 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1const__mem__functor1.html">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor1.html#a2c171737e0c7dc6ae00f73f1580a976d">const_mem_functor1</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor1.html">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor1.html#aba30421222bd496f9dec9b733fe70447">const_mem_functor1</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor1.html">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor1.html#af791174008d5b58aa0f4fb42a531cc4a">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor1.html">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor1.html#a14e585a05b63c5e4790b3de75cb18c96">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor1.html">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor1.html#a9e549ccae24d5a7d1741f17c09db7d5f">operator()</a>(const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor1.html">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor1.html#a3a575262ae2d62c39c52280017956a95">operator()</a>(const T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor1.html">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor1.html#a8ba6a6565b8a29812e266aa4e5261a2d">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor1.html">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::const_mem_functor1< T_return, T_obj, T_arg1 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__mem__functor1.html">const_mem_functor1</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1const__mem__functor1-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::const_mem_functor1< T_return, T_obj, T_arg1 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1const__mem__functor1.html" title="const_mem_functor1 wraps const methods with 1 argument(s).">const_mem_functor1</a> wraps const methods with 1 argument(s).
+ <a href="classsigc_1_1const__mem__functor1.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::const_mem_functor1< T_return, T_obj, T_arg1 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1const__mem__functor1__inherit__graph.png" border="0" usemap="#asigc_1_1const__mem__functor1_3_01T__return_00_01T__obj_00_01T__arg1_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1const__mem__functor1_3_01T__return_00_01T__obj_00_01T__arg1_01_4_inherit__map" id="asigc_1_1const__mem__functor1_3_01T__return_00_01T__obj_00_01T__arg1_01_4_inherit__map">
+<area shape="rect" title="const_mem_functor1 wraps const methods with 1 argument(s)." alt="" coords="5,80,207,121"/>
+<area shape="rect" href="classsigc_1_1bound__const__mem__functor1.html" title="bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance." alt="" coords="17,169,195,225"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="36,5,176,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a14e585a05b63c5e4790b3de75cb18c96"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor1.html#a14e585a05b63c5e4790b3de75cb18c96">function_type</a>) (T_arg1) const</td></tr>
+<tr class="separator:a14e585a05b63c5e4790b3de75cb18c96"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8ba6a6565b8a29812e266aa4e5261a2d"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor1.html#a8ba6a6565b8a29812e266aa4e5261a2d">result_type</a></td></tr>
+<tr class="separator:a8ba6a6565b8a29812e266aa4e5261a2d"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a2c171737e0c7dc6ae00f73f1580a976d"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor1.html#a2c171737e0c7dc6ae00f73f1580a976d">const_mem_functor1</a> ()</td></tr>
+<tr class="memdesc:a2c171737e0c7dc6ae00f73f1580a976d"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__mem__functor1.html#a2c171737e0c7dc6ae00f73f1580a976d">More...</a><br /></td></tr>
+<tr class="separator:a2c171737e0c7dc6ae00f73f1580a976d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba30421222bd496f9dec9b733fe70447"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor1.html#aba30421222bd496f9dec9b733fe70447">const_mem_functor1</a> (<a class="el" href="classsigc_1_1const__mem__functor1.html#a14e585a05b63c5e4790b3de75cb18c96">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:aba30421222bd496f9dec9b733fe70447"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__mem__functor1.html" title="const_mem_functor1 wraps const methods with 1 argument(s).">const_mem_functor1</a> object that wraps the passed method. <a href="classsigc_1_1const__mem__functor1.html#aba30421222bd496f9dec9b733fe70447">More...</a><br /></td></tr>
+<tr class="separator:aba30421222bd496f9dec9b733fe70447"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3a575262ae2d62c39c52280017956a95"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor1.html#a3a575262ae2d62c39c52280017956a95">operator()</a> (const T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a3a575262ae2d62c39c52280017956a95"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor1.html#a3a575262ae2d62c39c52280017956a95">More...</a><br /></td></tr>
+<tr class="separator:a3a575262ae2d62c39c52280017956a95"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9e549ccae24d5a7d1741f17c09db7d5f"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor1.html#a9e549ccae24d5a7d1741f17c09db7d5f">operator()</a> (const T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a9e549ccae24d5a7d1741f17c09db7d5f"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor1.html#a9e549ccae24d5a7d1741f17c09db7d5f">More...</a><br /></td></tr>
+<tr class="separator:a9e549ccae24d5a7d1741f17c09db7d5f"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:af791174008d5b58aa0f4fb42a531cc4a"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor1.html#a14e585a05b63c5e4790b3de75cb18c96">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor1.html#af791174008d5b58aa0f4fb42a531cc4a">func_ptr_</a></td></tr>
+<tr class="separator:af791174008d5b58aa0f4fb42a531cc4a"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1><br />
+class sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></h3>
+
+<p><a class="el" href="classsigc_1_1const__mem__functor1.html" title="const_mem_functor1 wraps const methods with 1 argument(s).">const_mem_functor1</a> wraps const methods with 1 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1const__mem__functor1.html" title="const_mem_functor1 wraps const methods with 1 argument(s).">const_mem_functor1</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__mem__functor1.html#a9e549ccae24d5a7d1741f17c09db7d5f" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1const__mem__functor1.html#a9e549ccae24d5a7d1741f17c09db7d5f" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a14e585a05b63c5e4790b3de75cb18c96"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a14e585a05b63c5e4790b3de75cb18c96">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1const__mem__functor1.html">sigc::const_mem_functor1</a>< T_return, T_obj, T_arg1 >::function_type) (T_arg1) const</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a8ba6a6565b8a29812e266aa4e5261a2d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8ba6a6565b8a29812e266aa4e5261a2d">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1const__mem__functor1.html">sigc::const_mem_functor1</a>< T_return, T_obj, T_arg1 >::<a class="el" href="classsigc_1_1const__mem__functor1.html#a8ba6a6565b8a29812e266aa4e5261a2d">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a2c171737e0c7dc6ae00f73f1580a976d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2c171737e0c7dc6ae00f73f1580a976d">◆ </a></span>const_mem_functor1() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor1.html">sigc::const_mem_functor1</a>< T_return, T_obj, T_arg1 >::<a class="el" href="classsigc_1_1const__mem__functor1.html">const_mem_functor1</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="aba30421222bd496f9dec9b733fe70447"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aba30421222bd496f9dec9b733fe70447">◆ </a></span>const_mem_functor1() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor1.html">sigc::const_mem_functor1</a>< T_return, T_obj, T_arg1 >::<a class="el" href="classsigc_1_1const__mem__functor1.html">const_mem_functor1</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1const__mem__functor1.html#a14e585a05b63c5e4790b3de75cb18c96">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1const__mem__functor1.html" title="const_mem_functor1 wraps const methods with 1 argument(s).">const_mem_functor1</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1const__mem__functor1.html#a9e549ccae24d5a7d1741f17c09db7d5f" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a3a575262ae2d62c39c52280017956a95"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3a575262ae2d62c39c52280017956a95">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__mem__functor1.html">sigc::const_mem_functor1</a>< T_return, T_obj, T_arg1 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a9e549ccae24d5a7d1741f17c09db7d5f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9e549ccae24d5a7d1741f17c09db7d5f">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__mem__functor1.html">sigc::const_mem_functor1</a>< T_return, T_obj, T_arg1 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000139">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="af791174008d5b58aa0f4fb42a531cc4a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af791174008d5b58aa0f4fb42a531cc4a">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor1.html#a14e585a05b63c5e4790b3de75cb18c96">function_type</a> <a class="el" href="classsigc_1_1const__mem__functor1.html">sigc::const_mem_functor1</a>< T_return, T_obj, T_arg1 >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::const_mem_functor1< T_return, T_obj, T_arg1 >" name="sigc::const_mem_functor1< T_return, T_obj, T_arg1 >">
+<area shape="rect" id="node1" title="const_mem_functor1 wraps const methods with 1 argument(s)." alt="" coords="5,80,207,121"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__const__mem__functor1.html" title="bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance." alt="" coords="17,169,195,225"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="36,5,176,32"/>
+</map>
--- /dev/null
+0eb2be486d77d86d1d3eebf6b14b0a8c
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__mem__functor2.html">const_mem_functor2</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1const__mem__functor2.html">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor2.html#a6265bdc51f35d8d5274bfeb8cdafc1dc">const_mem_functor2</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor2.html">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor2.html#ab281b110d1fbba86e2d58f9607d0f0c3">const_mem_functor2</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor2.html">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor2.html#a4445ff55323e94d525c1b2574ee32ddc">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor2.html">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor2.html#a2294d014482fee6845b69ab5bc27daa9">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor2.html">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor2.html#a51c12b33270c350c8988194cb29df590">operator()</a>(const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor2.html">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor2.html#aafbf14880952214525553f4b419bf5c6">operator()</a>(const T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor2.html">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor2.html#a5eaa5f2ab10ad755c89ff5b09c1e281d">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor2.html">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__mem__functor2.html">const_mem_functor2</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1const__mem__functor2-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1const__mem__functor2.html" title="const_mem_functor2 wraps const methods with 2 argument(s).">const_mem_functor2</a> wraps const methods with 2 argument(s).
+ <a href="classsigc_1_1const__mem__functor2.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1const__mem__functor2__inherit__graph.png" border="0" usemap="#asigc_1_1const__mem__functor2_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1const__mem__functor2_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_01_4_inherit__map" id="asigc_1_1const__mem__functor2_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_01_4_inherit__map">
+<area shape="rect" title="const_mem_functor2 wraps const methods with 2 argument(s)." alt="" coords="5,80,199,136"/>
+<area shape="rect" href="classsigc_1_1bound__const__mem__functor2.html" title="bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance." alt="" coords="12,184,192,240"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="32,5,172,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a2294d014482fee6845b69ab5bc27daa9"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor2.html#a2294d014482fee6845b69ab5bc27daa9">function_type</a>) (T_arg1, T_arg2) const</td></tr>
+<tr class="separator:a2294d014482fee6845b69ab5bc27daa9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5eaa5f2ab10ad755c89ff5b09c1e281d"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor2.html#a5eaa5f2ab10ad755c89ff5b09c1e281d">result_type</a></td></tr>
+<tr class="separator:a5eaa5f2ab10ad755c89ff5b09c1e281d"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a6265bdc51f35d8d5274bfeb8cdafc1dc"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor2.html#a6265bdc51f35d8d5274bfeb8cdafc1dc">const_mem_functor2</a> ()</td></tr>
+<tr class="memdesc:a6265bdc51f35d8d5274bfeb8cdafc1dc"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__mem__functor2.html#a6265bdc51f35d8d5274bfeb8cdafc1dc">More...</a><br /></td></tr>
+<tr class="separator:a6265bdc51f35d8d5274bfeb8cdafc1dc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab281b110d1fbba86e2d58f9607d0f0c3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor2.html#ab281b110d1fbba86e2d58f9607d0f0c3">const_mem_functor2</a> (<a class="el" href="classsigc_1_1const__mem__functor2.html#a2294d014482fee6845b69ab5bc27daa9">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:ab281b110d1fbba86e2d58f9607d0f0c3"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__mem__functor2.html" title="const_mem_functor2 wraps const methods with 2 argument(s).">const_mem_functor2</a> object that wraps the passed method. <a href="classsigc_1_1const__mem__functor2.html#ab281b110d1fbba86e2d58f9607d0f0c3">More...</a><br /></td></tr>
+<tr class="separator:ab281b110d1fbba86e2d58f9607d0f0c3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aafbf14880952214525553f4b419bf5c6"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor2.html#aafbf14880952214525553f4b419bf5c6">operator()</a> (const T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:aafbf14880952214525553f4b419bf5c6"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor2.html#aafbf14880952214525553f4b419bf5c6">More...</a><br /></td></tr>
+<tr class="separator:aafbf14880952214525553f4b419bf5c6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a51c12b33270c350c8988194cb29df590"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor2.html#a51c12b33270c350c8988194cb29df590">operator()</a> (const T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:a51c12b33270c350c8988194cb29df590"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor2.html#a51c12b33270c350c8988194cb29df590">More...</a><br /></td></tr>
+<tr class="separator:a51c12b33270c350c8988194cb29df590"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:a4445ff55323e94d525c1b2574ee32ddc"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor2.html#a2294d014482fee6845b69ab5bc27daa9">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor2.html#a4445ff55323e94d525c1b2574ee32ddc">func_ptr_</a></td></tr>
+<tr class="separator:a4445ff55323e94d525c1b2574ee32ddc"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2><br />
+class sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></h3>
+
+<p><a class="el" href="classsigc_1_1const__mem__functor2.html" title="const_mem_functor2 wraps const methods with 2 argument(s).">const_mem_functor2</a> wraps const methods with 2 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1const__mem__functor2.html" title="const_mem_functor2 wraps const methods with 2 argument(s).">const_mem_functor2</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__mem__functor2.html#a51c12b33270c350c8988194cb29df590" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__mem__functor2.html#a51c12b33270c350c8988194cb29df590" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1const__mem__functor2.html#a51c12b33270c350c8988194cb29df590" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a2294d014482fee6845b69ab5bc27daa9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2294d014482fee6845b69ab5bc27daa9">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1const__mem__functor2.html">sigc::const_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::function_type) (T_arg1, T_arg2) const</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a5eaa5f2ab10ad755c89ff5b09c1e281d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5eaa5f2ab10ad755c89ff5b09c1e281d">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1const__mem__functor2.html">sigc::const_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1const__mem__functor2.html#a5eaa5f2ab10ad755c89ff5b09c1e281d">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a6265bdc51f35d8d5274bfeb8cdafc1dc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a6265bdc51f35d8d5274bfeb8cdafc1dc">◆ </a></span>const_mem_functor2() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor2.html">sigc::const_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1const__mem__functor2.html">const_mem_functor2</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="ab281b110d1fbba86e2d58f9607d0f0c3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab281b110d1fbba86e2d58f9607d0f0c3">◆ </a></span>const_mem_functor2() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor2.html">sigc::const_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1const__mem__functor2.html">const_mem_functor2</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1const__mem__functor2.html#a2294d014482fee6845b69ab5bc27daa9">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1const__mem__functor2.html" title="const_mem_functor2 wraps const methods with 2 argument(s).">const_mem_functor2</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1const__mem__functor2.html#a51c12b33270c350c8988194cb29df590" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="aafbf14880952214525553f4b419bf5c6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aafbf14880952214525553f4b419bf5c6">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__mem__functor2.html">sigc::const_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a51c12b33270c350c8988194cb29df590"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a51c12b33270c350c8988194cb29df590">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__mem__functor2.html">sigc::const_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000140">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a4445ff55323e94d525c1b2574ee32ddc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4445ff55323e94d525c1b2574ee32ddc">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor2.html#a2294d014482fee6845b69ab5bc27daa9">function_type</a> <a class="el" href="classsigc_1_1const__mem__functor2.html">sigc::const_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >" name="sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >">
+<area shape="rect" id="node1" title="const_mem_functor2 wraps const methods with 2 argument(s)." alt="" coords="5,80,199,136"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__const__mem__functor2.html" title="bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance." alt="" coords="12,184,192,240"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="32,5,172,32"/>
+</map>
--- /dev/null
+845023d844dfb507e8dc67dffd282636
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__mem__functor3.html">const_mem_functor3</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1const__mem__functor3.html">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor3.html#a9921cf28137404e029e3f5d7c291021d">const_mem_functor3</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor3.html">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor3.html#ae70cb6e5e322ef3f3a9673b1e541d2c1">const_mem_functor3</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor3.html">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor3.html#ad86eb326f14c401748d0a118265e558d">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor3.html">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor3.html#accd266c72527ca411756bd9a4045eac9">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor3.html">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor3.html#a6322fdc9cc492d4f3a2c8482e193540f">operator()</a>(const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor3.html">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor3.html#aa123c4fb39116ca1a28896cfd029b1de">operator()</a>(const T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor3.html">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor3.html#ae67fd219e64f81359640873d30123c9d">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor3.html">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__mem__functor3.html">const_mem_functor3</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1const__mem__functor3-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1const__mem__functor3.html" title="const_mem_functor3 wraps const methods with 3 argument(s).">const_mem_functor3</a> wraps const methods with 3 argument(s).
+ <a href="classsigc_1_1const__mem__functor3.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1const__mem__functor3__inherit__graph.png" border="0" usemap="#asigc_1_1const__mem__functor3_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1const__mem__functor3_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_01_4_inherit__map" id="asigc_1_1const__mem__functor3_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_01_4_inherit__map">
+<area shape="rect" title="const_mem_functor3 wraps const methods with 3 argument(s)." alt="" coords="5,80,199,136"/>
+<area shape="rect" href="classsigc_1_1bound__const__mem__functor3.html" title="bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance." alt="" coords="13,184,191,255"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="32,5,172,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:accd266c72527ca411756bd9a4045eac9"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor3.html#accd266c72527ca411756bd9a4045eac9">function_type</a>) (T_arg1, T_arg2, T_arg3) const</td></tr>
+<tr class="separator:accd266c72527ca411756bd9a4045eac9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae67fd219e64f81359640873d30123c9d"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor3.html#ae67fd219e64f81359640873d30123c9d">result_type</a></td></tr>
+<tr class="separator:ae67fd219e64f81359640873d30123c9d"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a9921cf28137404e029e3f5d7c291021d"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor3.html#a9921cf28137404e029e3f5d7c291021d">const_mem_functor3</a> ()</td></tr>
+<tr class="memdesc:a9921cf28137404e029e3f5d7c291021d"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__mem__functor3.html#a9921cf28137404e029e3f5d7c291021d">More...</a><br /></td></tr>
+<tr class="separator:a9921cf28137404e029e3f5d7c291021d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae70cb6e5e322ef3f3a9673b1e541d2c1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor3.html#ae70cb6e5e322ef3f3a9673b1e541d2c1">const_mem_functor3</a> (<a class="el" href="classsigc_1_1const__mem__functor3.html#accd266c72527ca411756bd9a4045eac9">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:ae70cb6e5e322ef3f3a9673b1e541d2c1"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__mem__functor3.html" title="const_mem_functor3 wraps const methods with 3 argument(s).">const_mem_functor3</a> object that wraps the passed method. <a href="classsigc_1_1const__mem__functor3.html#ae70cb6e5e322ef3f3a9673b1e541d2c1">More...</a><br /></td></tr>
+<tr class="separator:ae70cb6e5e322ef3f3a9673b1e541d2c1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa123c4fb39116ca1a28896cfd029b1de"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor3.html#aa123c4fb39116ca1a28896cfd029b1de">operator()</a> (const T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:aa123c4fb39116ca1a28896cfd029b1de"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor3.html#aa123c4fb39116ca1a28896cfd029b1de">More...</a><br /></td></tr>
+<tr class="separator:aa123c4fb39116ca1a28896cfd029b1de"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a6322fdc9cc492d4f3a2c8482e193540f"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor3.html#a6322fdc9cc492d4f3a2c8482e193540f">operator()</a> (const T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:a6322fdc9cc492d4f3a2c8482e193540f"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor3.html#a6322fdc9cc492d4f3a2c8482e193540f">More...</a><br /></td></tr>
+<tr class="separator:a6322fdc9cc492d4f3a2c8482e193540f"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:ad86eb326f14c401748d0a118265e558d"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor3.html#accd266c72527ca411756bd9a4045eac9">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor3.html#ad86eb326f14c401748d0a118265e558d">func_ptr_</a></td></tr>
+<tr class="separator:ad86eb326f14c401748d0a118265e558d"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3><br />
+class sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></h3>
+
+<p><a class="el" href="classsigc_1_1const__mem__functor3.html" title="const_mem_functor3 wraps const methods with 3 argument(s).">const_mem_functor3</a> wraps const methods with 3 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1const__mem__functor3.html" title="const_mem_functor3 wraps const methods with 3 argument(s).">const_mem_functor3</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__mem__functor3.html#a6322fdc9cc492d4f3a2c8482e193540f" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__mem__functor3.html#a6322fdc9cc492d4f3a2c8482e193540f" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__mem__functor3.html#a6322fdc9cc492d4f3a2c8482e193540f" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1const__mem__functor3.html#a6322fdc9cc492d4f3a2c8482e193540f" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="accd266c72527ca411756bd9a4045eac9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#accd266c72527ca411756bd9a4045eac9">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1const__mem__functor3.html">sigc::const_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::function_type) (T_arg1, T_arg2, T_arg3) const</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ae67fd219e64f81359640873d30123c9d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae67fd219e64f81359640873d30123c9d">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1const__mem__functor3.html">sigc::const_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1const__mem__functor3.html#ae67fd219e64f81359640873d30123c9d">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a9921cf28137404e029e3f5d7c291021d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9921cf28137404e029e3f5d7c291021d">◆ </a></span>const_mem_functor3() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor3.html">sigc::const_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1const__mem__functor3.html">const_mem_functor3</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="ae70cb6e5e322ef3f3a9673b1e541d2c1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae70cb6e5e322ef3f3a9673b1e541d2c1">◆ </a></span>const_mem_functor3() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor3.html">sigc::const_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1const__mem__functor3.html">const_mem_functor3</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1const__mem__functor3.html#accd266c72527ca411756bd9a4045eac9">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1const__mem__functor3.html" title="const_mem_functor3 wraps const methods with 3 argument(s).">const_mem_functor3</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1const__mem__functor3.html#a6322fdc9cc492d4f3a2c8482e193540f" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="aa123c4fb39116ca1a28896cfd029b1de"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa123c4fb39116ca1a28896cfd029b1de">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__mem__functor3.html">sigc::const_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a6322fdc9cc492d4f3a2c8482e193540f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a6322fdc9cc492d4f3a2c8482e193540f">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__mem__functor3.html">sigc::const_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000141">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="ad86eb326f14c401748d0a118265e558d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad86eb326f14c401748d0a118265e558d">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor3.html#accd266c72527ca411756bd9a4045eac9">function_type</a> <a class="el" href="classsigc_1_1const__mem__functor3.html">sigc::const_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >" name="sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >">
+<area shape="rect" id="node1" title="const_mem_functor3 wraps const methods with 3 argument(s)." alt="" coords="5,80,199,136"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__const__mem__functor3.html" title="bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance." alt="" coords="13,184,191,255"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="32,5,172,32"/>
+</map>
--- /dev/null
+a4a803bbbdf7822c56e6cd424bf3a265
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__mem__functor4.html">const_mem_functor4</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1const__mem__functor4.html">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor4.html#acdde68d1638c13cd29157d1cb1bd42d2">const_mem_functor4</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor4.html">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor4.html#a7e09703c6320542cb5f0075d371908a8">const_mem_functor4</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor4.html">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor4.html#ac0feeedacde97bd166141c285fa2c74c">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor4.html">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor4.html#a775bb61661f2a7007b36f16ee106a8ad">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor4.html">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor4.html#a5b178876ca9fbec1fa2339819939a9e7">operator()</a>(const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor4.html">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor4.html#a25b73f70e0cb8771a6fc8dd1ad521795">operator()</a>(const T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor4.html">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor4.html#a78069750e64446199d91c0682b0915cc">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor4.html">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__mem__functor4.html">const_mem_functor4</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1const__mem__functor4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1const__mem__functor4.html" title="const_mem_functor4 wraps const methods with 4 argument(s).">const_mem_functor4</a> wraps const methods with 4 argument(s).
+ <a href="classsigc_1_1const__mem__functor4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1const__mem__functor4__inherit__graph.png" border="0" usemap="#asigc_1_1const__mem__functor4_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1const__mem__functor4_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_01_4_inherit__map" id="asigc_1_1const__mem__functor4_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_01_4_inherit__map">
+<area shape="rect" title="const_mem_functor4 wraps const methods with 4 argument(s)." alt="" coords="193,13,387,69"/>
+<area shape="rect" href="classsigc_1_1bound__const__mem__functor4.html" title="bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance." alt="" coords="435,5,613,76"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,27,145,54"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a775bb61661f2a7007b36f16ee106a8ad"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor4.html#a775bb61661f2a7007b36f16ee106a8ad">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4) const</td></tr>
+<tr class="separator:a775bb61661f2a7007b36f16ee106a8ad"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a78069750e64446199d91c0682b0915cc"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor4.html#a78069750e64446199d91c0682b0915cc">result_type</a></td></tr>
+<tr class="separator:a78069750e64446199d91c0682b0915cc"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:acdde68d1638c13cd29157d1cb1bd42d2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor4.html#acdde68d1638c13cd29157d1cb1bd42d2">const_mem_functor4</a> ()</td></tr>
+<tr class="memdesc:acdde68d1638c13cd29157d1cb1bd42d2"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__mem__functor4.html#acdde68d1638c13cd29157d1cb1bd42d2">More...</a><br /></td></tr>
+<tr class="separator:acdde68d1638c13cd29157d1cb1bd42d2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7e09703c6320542cb5f0075d371908a8"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor4.html#a7e09703c6320542cb5f0075d371908a8">const_mem_functor4</a> (<a class="el" href="classsigc_1_1const__mem__functor4.html#a775bb61661f2a7007b36f16ee106a8ad">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a7e09703c6320542cb5f0075d371908a8"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__mem__functor4.html" title="const_mem_functor4 wraps const methods with 4 argument(s).">const_mem_functor4</a> object that wraps the passed method. <a href="classsigc_1_1const__mem__functor4.html#a7e09703c6320542cb5f0075d371908a8">More...</a><br /></td></tr>
+<tr class="separator:a7e09703c6320542cb5f0075d371908a8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a25b73f70e0cb8771a6fc8dd1ad521795"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor4.html#a25b73f70e0cb8771a6fc8dd1ad521795">operator()</a> (const T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:a25b73f70e0cb8771a6fc8dd1ad521795"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor4.html#a25b73f70e0cb8771a6fc8dd1ad521795">More...</a><br /></td></tr>
+<tr class="separator:a25b73f70e0cb8771a6fc8dd1ad521795"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5b178876ca9fbec1fa2339819939a9e7"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor4.html#a5b178876ca9fbec1fa2339819939a9e7">operator()</a> (const T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:a5b178876ca9fbec1fa2339819939a9e7"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor4.html#a5b178876ca9fbec1fa2339819939a9e7">More...</a><br /></td></tr>
+<tr class="separator:a5b178876ca9fbec1fa2339819939a9e7"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:ac0feeedacde97bd166141c285fa2c74c"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor4.html#a775bb61661f2a7007b36f16ee106a8ad">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor4.html#ac0feeedacde97bd166141c285fa2c74c">func_ptr_</a></td></tr>
+<tr class="separator:ac0feeedacde97bd166141c285fa2c74c"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4><br />
+class sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></h3>
+
+<p><a class="el" href="classsigc_1_1const__mem__functor4.html" title="const_mem_functor4 wraps const methods with 4 argument(s).">const_mem_functor4</a> wraps const methods with 4 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1const__mem__functor4.html" title="const_mem_functor4 wraps const methods with 4 argument(s).">const_mem_functor4</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__mem__functor4.html#a5b178876ca9fbec1fa2339819939a9e7" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__mem__functor4.html#a5b178876ca9fbec1fa2339819939a9e7" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__mem__functor4.html#a5b178876ca9fbec1fa2339819939a9e7" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__mem__functor4.html#a5b178876ca9fbec1fa2339819939a9e7" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1const__mem__functor4.html#a5b178876ca9fbec1fa2339819939a9e7" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a775bb61661f2a7007b36f16ee106a8ad"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a775bb61661f2a7007b36f16ee106a8ad">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1const__mem__functor4.html">sigc::const_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::function_type) (T_arg1, T_arg2, T_arg3, T_arg4) const</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a78069750e64446199d91c0682b0915cc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a78069750e64446199d91c0682b0915cc">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1const__mem__functor4.html">sigc::const_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1const__mem__functor4.html#a78069750e64446199d91c0682b0915cc">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="acdde68d1638c13cd29157d1cb1bd42d2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#acdde68d1638c13cd29157d1cb1bd42d2">◆ </a></span>const_mem_functor4() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor4.html">sigc::const_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1const__mem__functor4.html">const_mem_functor4</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="a7e09703c6320542cb5f0075d371908a8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7e09703c6320542cb5f0075d371908a8">◆ </a></span>const_mem_functor4() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor4.html">sigc::const_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1const__mem__functor4.html">const_mem_functor4</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1const__mem__functor4.html#a775bb61661f2a7007b36f16ee106a8ad">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1const__mem__functor4.html" title="const_mem_functor4 wraps const methods with 4 argument(s).">const_mem_functor4</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1const__mem__functor4.html#a5b178876ca9fbec1fa2339819939a9e7" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a25b73f70e0cb8771a6fc8dd1ad521795"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a25b73f70e0cb8771a6fc8dd1ad521795">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__mem__functor4.html">sigc::const_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a5b178876ca9fbec1fa2339819939a9e7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5b178876ca9fbec1fa2339819939a9e7">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__mem__functor4.html">sigc::const_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000142">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="ac0feeedacde97bd166141c285fa2c74c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac0feeedacde97bd166141c285fa2c74c">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor4.html#a775bb61661f2a7007b36f16ee106a8ad">function_type</a> <a class="el" href="classsigc_1_1const__mem__functor4.html">sigc::const_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >" name="sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >">
+<area shape="rect" id="node1" title="const_mem_functor4 wraps const methods with 4 argument(s)." alt="" coords="193,13,387,69"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__const__mem__functor4.html" title="bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance." alt="" coords="435,5,613,76"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,27,145,54"/>
+</map>
--- /dev/null
+f5759c7ec964307c32a49c87069513ed
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__mem__functor5.html">const_mem_functor5</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1const__mem__functor5.html">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor5.html#a818da40f7c82d6a1fde3009d32bf3920">const_mem_functor5</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor5.html">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor5.html#a47769ef46d8ff779df8c152acdc0d74c">const_mem_functor5</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor5.html">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor5.html#aeb6e66e0304e5c039d97264a3dd7d6e9">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor5.html">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor5.html#aa58310b256b11e94d9a757acf60b410a">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor5.html">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor5.html#ae710c03998c58cb8f90ce75a46fab69c">operator()</a>(const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor5.html">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor5.html#aaceffe6505aed22dd5af369231914965">operator()</a>(const T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor5.html">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor5.html#a9d952d52dade789bc38953c4c83fb425">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor5.html">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__mem__functor5.html">const_mem_functor5</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1const__mem__functor5-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1const__mem__functor5.html" title="const_mem_functor5 wraps const methods with 5 argument(s).">const_mem_functor5</a> wraps const methods with 5 argument(s).
+ <a href="classsigc_1_1const__mem__functor5.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1const__mem__functor5__inherit__graph.png" border="0" usemap="#asigc_1_1const__mem__functor5_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1const__mem__functor5_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_01_4_inherit__map" id="asigc_1_1const__mem__functor5_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_01_4_inherit__map">
+<area shape="rect" title="const_mem_functor5 wraps const methods with 5 argument(s)." alt="" coords="193,5,387,76"/>
+<area shape="rect" href="classsigc_1_1bound__const__mem__functor5.html" title="bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance." alt="" coords="435,5,624,76"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,27,145,54"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:aa58310b256b11e94d9a757acf60b410a"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor5.html#aa58310b256b11e94d9a757acf60b410a">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const</td></tr>
+<tr class="separator:aa58310b256b11e94d9a757acf60b410a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9d952d52dade789bc38953c4c83fb425"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor5.html#a9d952d52dade789bc38953c4c83fb425">result_type</a></td></tr>
+<tr class="separator:a9d952d52dade789bc38953c4c83fb425"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a818da40f7c82d6a1fde3009d32bf3920"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor5.html#a818da40f7c82d6a1fde3009d32bf3920">const_mem_functor5</a> ()</td></tr>
+<tr class="memdesc:a818da40f7c82d6a1fde3009d32bf3920"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__mem__functor5.html#a818da40f7c82d6a1fde3009d32bf3920">More...</a><br /></td></tr>
+<tr class="separator:a818da40f7c82d6a1fde3009d32bf3920"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a47769ef46d8ff779df8c152acdc0d74c"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor5.html#a47769ef46d8ff779df8c152acdc0d74c">const_mem_functor5</a> (<a class="el" href="classsigc_1_1const__mem__functor5.html#aa58310b256b11e94d9a757acf60b410a">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a47769ef46d8ff779df8c152acdc0d74c"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__mem__functor5.html" title="const_mem_functor5 wraps const methods with 5 argument(s).">const_mem_functor5</a> object that wraps the passed method. <a href="classsigc_1_1const__mem__functor5.html#a47769ef46d8ff779df8c152acdc0d74c">More...</a><br /></td></tr>
+<tr class="separator:a47769ef46d8ff779df8c152acdc0d74c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aaceffe6505aed22dd5af369231914965"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor5.html#aaceffe6505aed22dd5af369231914965">operator()</a> (const T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:aaceffe6505aed22dd5af369231914965"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor5.html#aaceffe6505aed22dd5af369231914965">More...</a><br /></td></tr>
+<tr class="separator:aaceffe6505aed22dd5af369231914965"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae710c03998c58cb8f90ce75a46fab69c"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor5.html#ae710c03998c58cb8f90ce75a46fab69c">operator()</a> (const T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:ae710c03998c58cb8f90ce75a46fab69c"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor5.html#ae710c03998c58cb8f90ce75a46fab69c">More...</a><br /></td></tr>
+<tr class="separator:ae710c03998c58cb8f90ce75a46fab69c"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:aeb6e66e0304e5c039d97264a3dd7d6e9"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor5.html#aa58310b256b11e94d9a757acf60b410a">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor5.html#aeb6e66e0304e5c039d97264a3dd7d6e9">func_ptr_</a></td></tr>
+<tr class="separator:aeb6e66e0304e5c039d97264a3dd7d6e9"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5><br />
+class sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></h3>
+
+<p><a class="el" href="classsigc_1_1const__mem__functor5.html" title="const_mem_functor5 wraps const methods with 5 argument(s).">const_mem_functor5</a> wraps const methods with 5 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1const__mem__functor5.html" title="const_mem_functor5 wraps const methods with 5 argument(s).">const_mem_functor5</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__mem__functor5.html#ae710c03998c58cb8f90ce75a46fab69c" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__mem__functor5.html#ae710c03998c58cb8f90ce75a46fab69c" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__mem__functor5.html#ae710c03998c58cb8f90ce75a46fab69c" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__mem__functor5.html#ae710c03998c58cb8f90ce75a46fab69c" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__mem__functor5.html#ae710c03998c58cb8f90ce75a46fab69c" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1const__mem__functor5.html#ae710c03998c58cb8f90ce75a46fab69c" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="aa58310b256b11e94d9a757acf60b410a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa58310b256b11e94d9a757acf60b410a">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1const__mem__functor5.html">sigc::const_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::function_type) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a9d952d52dade789bc38953c4c83fb425"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9d952d52dade789bc38953c4c83fb425">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1const__mem__functor5.html">sigc::const_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1const__mem__functor5.html#a9d952d52dade789bc38953c4c83fb425">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a818da40f7c82d6a1fde3009d32bf3920"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a818da40f7c82d6a1fde3009d32bf3920">◆ </a></span>const_mem_functor5() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor5.html">sigc::const_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1const__mem__functor5.html">const_mem_functor5</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="a47769ef46d8ff779df8c152acdc0d74c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a47769ef46d8ff779df8c152acdc0d74c">◆ </a></span>const_mem_functor5() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor5.html">sigc::const_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1const__mem__functor5.html">const_mem_functor5</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1const__mem__functor5.html#aa58310b256b11e94d9a757acf60b410a">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1const__mem__functor5.html" title="const_mem_functor5 wraps const methods with 5 argument(s).">const_mem_functor5</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1const__mem__functor5.html#ae710c03998c58cb8f90ce75a46fab69c" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="aaceffe6505aed22dd5af369231914965"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aaceffe6505aed22dd5af369231914965">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__mem__functor5.html">sigc::const_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="ae710c03998c58cb8f90ce75a46fab69c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae710c03998c58cb8f90ce75a46fab69c">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__mem__functor5.html">sigc::const_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000143">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="aeb6e66e0304e5c039d97264a3dd7d6e9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aeb6e66e0304e5c039d97264a3dd7d6e9">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor5.html#aa58310b256b11e94d9a757acf60b410a">function_type</a> <a class="el" href="classsigc_1_1const__mem__functor5.html">sigc::const_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >" name="sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >">
+<area shape="rect" id="node1" title="const_mem_functor5 wraps const methods with 5 argument(s)." alt="" coords="193,5,387,76"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__const__mem__functor5.html" title="bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance." alt="" coords="435,5,624,76"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,27,145,54"/>
+</map>
--- /dev/null
+d18d1cc9538ca6eff493f8356a12591f
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__mem__functor6.html">const_mem_functor6</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1const__mem__functor6.html">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor6.html#a7a5e8a3a981a615a545aab358efa9472">const_mem_functor6</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor6.html">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor6.html#a0803b89f79b60c16d87c0372be261211">const_mem_functor6</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor6.html">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor6.html#a665c77c3da00d474d6d999c394801a98">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor6.html">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor6.html#ad64803b1192e1007887f234b8c7421ac">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor6.html">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor6.html#a023fd4cb845234b50c5dee1f4147cde9">operator()</a>(const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor6.html">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor6.html#a8657b806cb2eeb7e43f0a09f6556c514">operator()</a>(const T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor6.html">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor6.html#adf81aebfa633d0bf14a0d3f5e9688561">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor6.html">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__mem__functor6.html">const_mem_functor6</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1const__mem__functor6-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1const__mem__functor6.html" title="const_mem_functor6 wraps const methods with 6 argument(s).">const_mem_functor6</a> wraps const methods with 6 argument(s).
+ <a href="classsigc_1_1const__mem__functor6.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1const__mem__functor6__inherit__graph.png" border="0" usemap="#asigc_1_1const__mem__functor6_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1const__mem__functor6_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_01_4_inherit__map" id="asigc_1_1const__mem__functor6_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_01_4_inherit__map">
+<area shape="rect" title="const_mem_functor6 wraps const methods with 6 argument(s)." alt="" coords="193,13,387,83"/>
+<area shape="rect" href="classsigc_1_1bound__const__mem__functor6.html" title="bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance." alt="" coords="435,5,613,91"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,35,145,61"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:ad64803b1192e1007887f234b8c7421ac"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor6.html#ad64803b1192e1007887f234b8c7421ac">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const</td></tr>
+<tr class="separator:ad64803b1192e1007887f234b8c7421ac"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adf81aebfa633d0bf14a0d3f5e9688561"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor6.html#adf81aebfa633d0bf14a0d3f5e9688561">result_type</a></td></tr>
+<tr class="separator:adf81aebfa633d0bf14a0d3f5e9688561"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a7a5e8a3a981a615a545aab358efa9472"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor6.html#a7a5e8a3a981a615a545aab358efa9472">const_mem_functor6</a> ()</td></tr>
+<tr class="memdesc:a7a5e8a3a981a615a545aab358efa9472"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__mem__functor6.html#a7a5e8a3a981a615a545aab358efa9472">More...</a><br /></td></tr>
+<tr class="separator:a7a5e8a3a981a615a545aab358efa9472"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0803b89f79b60c16d87c0372be261211"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor6.html#a0803b89f79b60c16d87c0372be261211">const_mem_functor6</a> (<a class="el" href="classsigc_1_1const__mem__functor6.html#ad64803b1192e1007887f234b8c7421ac">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a0803b89f79b60c16d87c0372be261211"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__mem__functor6.html" title="const_mem_functor6 wraps const methods with 6 argument(s).">const_mem_functor6</a> object that wraps the passed method. <a href="classsigc_1_1const__mem__functor6.html#a0803b89f79b60c16d87c0372be261211">More...</a><br /></td></tr>
+<tr class="separator:a0803b89f79b60c16d87c0372be261211"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8657b806cb2eeb7e43f0a09f6556c514"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor6.html#a8657b806cb2eeb7e43f0a09f6556c514">operator()</a> (const T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:a8657b806cb2eeb7e43f0a09f6556c514"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor6.html#a8657b806cb2eeb7e43f0a09f6556c514">More...</a><br /></td></tr>
+<tr class="separator:a8657b806cb2eeb7e43f0a09f6556c514"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a023fd4cb845234b50c5dee1f4147cde9"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor6.html#a023fd4cb845234b50c5dee1f4147cde9">operator()</a> (const T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:a023fd4cb845234b50c5dee1f4147cde9"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor6.html#a023fd4cb845234b50c5dee1f4147cde9">More...</a><br /></td></tr>
+<tr class="separator:a023fd4cb845234b50c5dee1f4147cde9"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:a665c77c3da00d474d6d999c394801a98"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor6.html#ad64803b1192e1007887f234b8c7421ac">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor6.html#a665c77c3da00d474d6d999c394801a98">func_ptr_</a></td></tr>
+<tr class="separator:a665c77c3da00d474d6d999c394801a98"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6><br />
+class sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></h3>
+
+<p><a class="el" href="classsigc_1_1const__mem__functor6.html" title="const_mem_functor6 wraps const methods with 6 argument(s).">const_mem_functor6</a> wraps const methods with 6 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1const__mem__functor6.html" title="const_mem_functor6 wraps const methods with 6 argument(s).">const_mem_functor6</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__mem__functor6.html#a023fd4cb845234b50c5dee1f4147cde9" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__mem__functor6.html#a023fd4cb845234b50c5dee1f4147cde9" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__mem__functor6.html#a023fd4cb845234b50c5dee1f4147cde9" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__mem__functor6.html#a023fd4cb845234b50c5dee1f4147cde9" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__mem__functor6.html#a023fd4cb845234b50c5dee1f4147cde9" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg6</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__mem__functor6.html#a023fd4cb845234b50c5dee1f4147cde9" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1const__mem__functor6.html#a023fd4cb845234b50c5dee1f4147cde9" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="ad64803b1192e1007887f234b8c7421ac"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad64803b1192e1007887f234b8c7421ac">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1const__mem__functor6.html">sigc::const_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::function_type) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="adf81aebfa633d0bf14a0d3f5e9688561"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#adf81aebfa633d0bf14a0d3f5e9688561">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1const__mem__functor6.html">sigc::const_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1const__mem__functor6.html#adf81aebfa633d0bf14a0d3f5e9688561">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a7a5e8a3a981a615a545aab358efa9472"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7a5e8a3a981a615a545aab358efa9472">◆ </a></span>const_mem_functor6() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor6.html">sigc::const_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1const__mem__functor6.html">const_mem_functor6</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="a0803b89f79b60c16d87c0372be261211"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0803b89f79b60c16d87c0372be261211">◆ </a></span>const_mem_functor6() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor6.html">sigc::const_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1const__mem__functor6.html">const_mem_functor6</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1const__mem__functor6.html#ad64803b1192e1007887f234b8c7421ac">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1const__mem__functor6.html" title="const_mem_functor6 wraps const methods with 6 argument(s).">const_mem_functor6</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1const__mem__functor6.html#a023fd4cb845234b50c5dee1f4147cde9" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a8657b806cb2eeb7e43f0a09f6556c514"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8657b806cb2eeb7e43f0a09f6556c514">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__mem__functor6.html">sigc::const_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a023fd4cb845234b50c5dee1f4147cde9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a023fd4cb845234b50c5dee1f4147cde9">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__mem__functor6.html">sigc::const_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000144">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a665c77c3da00d474d6d999c394801a98"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a665c77c3da00d474d6d999c394801a98">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor6.html#ad64803b1192e1007887f234b8c7421ac">function_type</a> <a class="el" href="classsigc_1_1const__mem__functor6.html">sigc::const_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >" name="sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >">
+<area shape="rect" id="node1" title="const_mem_functor6 wraps const methods with 6 argument(s)." alt="" coords="193,13,387,83"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__const__mem__functor6.html" title="bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance." alt="" coords="435,5,613,91"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,35,145,61"/>
+</map>
--- /dev/null
+6929cbbe0ff2e13b63244e50c2485446
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__mem__functor7.html">const_mem_functor7</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1const__mem__functor7.html">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor7.html#add4d7f74905c6bc20afc6f7681f367c0">const_mem_functor7</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor7.html">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor7.html#a0538bba01694fc13456fcee0e96d8f34">const_mem_functor7</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor7.html">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor7.html#a255588607e165db8bd25c3bb8d7e1fbe">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor7.html">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor7.html#a73af81d23d0fa816b8ef00acb1970d43">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor7.html">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor7.html#a53f19248e5b61460759d7cdbf41ca21b">operator()</a>(const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor7.html">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor7.html#ab49dc9f302ef22e4b76043d9bc2f5062">operator()</a>(const T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor7.html">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor7.html#a724b8b210493e0d3cf06b5a393b91546">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__mem__functor7.html">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__mem__functor7.html">const_mem_functor7</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1const__mem__functor7-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1const__mem__functor7.html" title="const_mem_functor7 wraps const methods with 7 argument(s).">const_mem_functor7</a> wraps const methods with 7 argument(s).
+ <a href="classsigc_1_1const__mem__functor7.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1const__mem__functor7__inherit__graph.png" border="0" usemap="#asigc_1_1const__mem__functor7_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1const__mem__functor7_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map" id="asigc_1_1const__mem__functor7_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map">
+<area shape="rect" title="const_mem_functor7 wraps const methods with 7 argument(s)." alt="" coords="193,13,387,83"/>
+<area shape="rect" href="classsigc_1_1bound__const__mem__functor7.html" title="bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance." alt="" coords="435,5,613,91"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,35,145,61"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a73af81d23d0fa816b8ef00acb1970d43"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor7.html#a73af81d23d0fa816b8ef00acb1970d43">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const</td></tr>
+<tr class="separator:a73af81d23d0fa816b8ef00acb1970d43"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a724b8b210493e0d3cf06b5a393b91546"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor7.html#a724b8b210493e0d3cf06b5a393b91546">result_type</a></td></tr>
+<tr class="separator:a724b8b210493e0d3cf06b5a393b91546"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:add4d7f74905c6bc20afc6f7681f367c0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor7.html#add4d7f74905c6bc20afc6f7681f367c0">const_mem_functor7</a> ()</td></tr>
+<tr class="memdesc:add4d7f74905c6bc20afc6f7681f367c0"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__mem__functor7.html#add4d7f74905c6bc20afc6f7681f367c0">More...</a><br /></td></tr>
+<tr class="separator:add4d7f74905c6bc20afc6f7681f367c0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0538bba01694fc13456fcee0e96d8f34"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor7.html#a0538bba01694fc13456fcee0e96d8f34">const_mem_functor7</a> (<a class="el" href="classsigc_1_1const__mem__functor7.html#a73af81d23d0fa816b8ef00acb1970d43">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a0538bba01694fc13456fcee0e96d8f34"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__mem__functor7.html" title="const_mem_functor7 wraps const methods with 7 argument(s).">const_mem_functor7</a> object that wraps the passed method. <a href="classsigc_1_1const__mem__functor7.html#a0538bba01694fc13456fcee0e96d8f34">More...</a><br /></td></tr>
+<tr class="separator:a0538bba01694fc13456fcee0e96d8f34"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab49dc9f302ef22e4b76043d9bc2f5062"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor7.html#ab49dc9f302ef22e4b76043d9bc2f5062">operator()</a> (const T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:ab49dc9f302ef22e4b76043d9bc2f5062"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor7.html#ab49dc9f302ef22e4b76043d9bc2f5062">More...</a><br /></td></tr>
+<tr class="separator:ab49dc9f302ef22e4b76043d9bc2f5062"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a53f19248e5b61460759d7cdbf41ca21b"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor7.html#a53f19248e5b61460759d7cdbf41ca21b">operator()</a> (const T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:a53f19248e5b61460759d7cdbf41ca21b"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__mem__functor7.html#a53f19248e5b61460759d7cdbf41ca21b">More...</a><br /></td></tr>
+<tr class="separator:a53f19248e5b61460759d7cdbf41ca21b"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:a255588607e165db8bd25c3bb8d7e1fbe"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor7.html#a73af81d23d0fa816b8ef00acb1970d43">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor7.html#a255588607e165db8bd25c3bb8d7e1fbe">func_ptr_</a></td></tr>
+<tr class="separator:a255588607e165db8bd25c3bb8d7e1fbe"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7><br />
+class sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></h3>
+
+<p><a class="el" href="classsigc_1_1const__mem__functor7.html" title="const_mem_functor7 wraps const methods with 7 argument(s).">const_mem_functor7</a> wraps const methods with 7 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1const__mem__functor7.html" title="const_mem_functor7 wraps const methods with 7 argument(s).">const_mem_functor7</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__mem__functor7.html#a53f19248e5b61460759d7cdbf41ca21b" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__mem__functor7.html#a53f19248e5b61460759d7cdbf41ca21b" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__mem__functor7.html#a53f19248e5b61460759d7cdbf41ca21b" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__mem__functor7.html#a53f19248e5b61460759d7cdbf41ca21b" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__mem__functor7.html#a53f19248e5b61460759d7cdbf41ca21b" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg6</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__mem__functor7.html#a53f19248e5b61460759d7cdbf41ca21b" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg7</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__mem__functor7.html#a53f19248e5b61460759d7cdbf41ca21b" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1const__mem__functor7.html#a53f19248e5b61460759d7cdbf41ca21b" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a73af81d23d0fa816b8ef00acb1970d43"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a73af81d23d0fa816b8ef00acb1970d43">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1const__mem__functor7.html">sigc::const_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::function_type) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a724b8b210493e0d3cf06b5a393b91546"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a724b8b210493e0d3cf06b5a393b91546">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1const__mem__functor7.html">sigc::const_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1const__mem__functor7.html#a724b8b210493e0d3cf06b5a393b91546">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="add4d7f74905c6bc20afc6f7681f367c0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#add4d7f74905c6bc20afc6f7681f367c0">◆ </a></span>const_mem_functor7() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor7.html">sigc::const_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1const__mem__functor7.html">const_mem_functor7</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="a0538bba01694fc13456fcee0e96d8f34"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0538bba01694fc13456fcee0e96d8f34">◆ </a></span>const_mem_functor7() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor7.html">sigc::const_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1const__mem__functor7.html">const_mem_functor7</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1const__mem__functor7.html#a73af81d23d0fa816b8ef00acb1970d43">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1const__mem__functor7.html" title="const_mem_functor7 wraps const methods with 7 argument(s).">const_mem_functor7</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1const__mem__functor7.html#a53f19248e5b61460759d7cdbf41ca21b" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="ab49dc9f302ef22e4b76043d9bc2f5062"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab49dc9f302ef22e4b76043d9bc2f5062">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__mem__functor7.html">sigc::const_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > </td>
+ <td class="paramname"><em>_A_a7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a7</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a53f19248e5b61460759d7cdbf41ca21b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a53f19248e5b61460759d7cdbf41ca21b">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__mem__functor7.html">sigc::const_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > </td>
+ <td class="paramname"><em>_A_a7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000145">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a7</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a255588607e165db8bd25c3bb8d7e1fbe"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a255588607e165db8bd25c3bb8d7e1fbe">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor7.html#a73af81d23d0fa816b8ef00acb1970d43">function_type</a> <a class="el" href="classsigc_1_1const__mem__functor7.html">sigc::const_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >" name="sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >">
+<area shape="rect" id="node1" title="const_mem_functor7 wraps const methods with 7 argument(s)." alt="" coords="193,13,387,83"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__const__mem__functor7.html" title="bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance." alt="" coords="435,5,613,91"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,35,145,61"/>
+</map>
--- /dev/null
+02790338c67ed962e8da2d5fba2afcf7
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html">const_volatile_limit_reference</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::const_volatile_limit_reference< T_type, I_derives_trackable > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1const__volatile__limit__reference.html">sigc::const_volatile_limit_reference< T_type, I_derives_trackable ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html#a9a01809bae79cb1b13ee50ce9d84dcb8">const_volatile_limit_reference</a>(const T_type & _A_target)</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html">sigc::const_volatile_limit_reference< T_type, I_derives_trackable ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html#ac09d022e8991a946d49a714df8b2f1c7">invoke</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html">sigc::const_volatile_limit_reference< T_type, I_derives_trackable ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html#a41c17ef86e8c65998ba42097c7ad5f09">visit</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html">sigc::const_volatile_limit_reference< T_type, I_derives_trackable ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::const_volatile_limit_reference< T_type, I_derives_trackable > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html">const_volatile_limit_reference</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1const__volatile__limit__reference-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::const_volatile_limit_reference< T_type, I_derives_trackable > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>A const_volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>, then <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each<>()</a> will "limit" itself to the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference instead of the derived reference.
+ <a href="classsigc_1_1const__volatile__limit__reference.html#details">More...</a></p>
+
+<p><code>#include <sigc++/limit_reference.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a9a01809bae79cb1b13ee50ce9d84dcb8"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html#a9a01809bae79cb1b13ee50ce9d84dcb8">const_volatile_limit_reference</a> (const T_type & _A_target)</td></tr>
+<tr class="memdesc:a9a01809bae79cb1b13ee50ce9d84dcb8"><td class="mdescLeft"> </td><td class="mdescRight">Constructor. <a href="classsigc_1_1const__volatile__limit__reference.html#a9a01809bae79cb1b13ee50ce9d84dcb8">More...</a><br /></td></tr>
+<tr class="separator:a9a01809bae79cb1b13ee50ce9d84dcb8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac09d022e8991a946d49a714df8b2f1c7"><td class="memItemLeft" align="right" valign="top">const volatile T_type & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html#ac09d022e8991a946d49a714df8b2f1c7">invoke</a> () const</td></tr>
+<tr class="memdesc:ac09d022e8991a946d49a714df8b2f1c7"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the reference. <a href="classsigc_1_1const__volatile__limit__reference.html#ac09d022e8991a946d49a714df8b2f1c7">More...</a><br /></td></tr>
+<tr class="separator:ac09d022e8991a946d49a714df8b2f1c7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a41c17ef86e8c65998ba42097c7ad5f09"><td class="memItemLeft" align="right" valign="top">const T_type & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html#a41c17ef86e8c65998ba42097c7ad5f09">visit</a> () const</td></tr>
+<tr class="memdesc:a41c17ef86e8c65998ba42097c7ad5f09"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the entity to visit for <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each()</a>. <a href="classsigc_1_1const__volatile__limit__reference.html#a41c17ef86e8c65998ba42097c7ad5f09">More...</a><br /></td></tr>
+<tr class="separator:a41c17ef86e8c65998ba42097c7ad5f09"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_type, bool I_derives_trackable = std::is_base_of<trackable, T_type>::value><br />
+class sigc::const_volatile_limit_reference< T_type, I_derives_trackable ></h3>
+
+<p>A const_volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>, then <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each<>()</a> will "limit" itself to the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference instead of the derived reference. </p>
+<p>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.</p>
+<p>If Foo inherits from trackable then both the derived reference and the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference are stored, so we can later retrieve the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference without doing an implicit conversion. To retrieve the derived reference (so that you invoke methods or members of it), use <a class="el" href="classsigc_1_1const__volatile__limit__reference.html#ac09d022e8991a946d49a714df8b2f1c7" title="Retrieve the reference.">invoke()</a>. To retrieve the trackable reference (so that you can call <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each()</a> on it), you use <a class="el" href="classsigc_1_1const__volatile__limit__reference.html#a41c17ef86e8c65998ba42097c7ad5f09" title="Retrieve the entity to visit for visit_each().">visit()</a>.</p>
+<p>If Foo does not inherit from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> then <a class="el" href="classsigc_1_1const__volatile__limit__reference.html#ac09d022e8991a946d49a714df8b2f1c7" title="Retrieve the reference.">invoke()</a> and <a class="el" href="classsigc_1_1const__volatile__limit__reference.html#a41c17ef86e8c65998ba42097c7ad5f09" title="Retrieve the entity to visit for visit_each().">visit()</a> just return the derived reference.</p>
+<p>This is used for bound (<a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">sigc::bind</a>) slot parameters (via <a class="el" href="classsigc_1_1bound__argument.html" title="A bound_argument<Foo> object stores a bound (for instance, with sigc::bind(), or sigc::bind_return())...">bound_argument</a>), bound return values, and, with <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a>, the reference to the handling object.</p>
+<ul>
+<li><em>T_type</em> The type of the reference. </li>
+</ul>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a9a01809bae79cb1b13ee50ce9d84dcb8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9a01809bae79cb1b13ee50ce9d84dcb8">◆ </a></span>const_volatile_limit_reference()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type , bool I_derives_trackable = std::is_base_of<trackable, T_type>::value> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html">sigc::const_volatile_limit_reference</a>< T_type, I_derives_trackable >::<a class="el" href="classsigc_1_1const__volatile__limit__reference.html">const_volatile_limit_reference</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_type & </td>
+ <td class="paramname"><em>_A_target</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_target</td><td>The reference to limit. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="ac09d022e8991a946d49a714df8b2f1c7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac09d022e8991a946d49a714df8b2f1c7">◆ </a></span>invoke()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type , bool I_derives_trackable = std::is_base_of<trackable, T_type>::value> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">const volatile T_type& <a class="el" href="classsigc_1_1const__volatile__limit__reference.html">sigc::const_volatile_limit_reference</a>< T_type, I_derives_trackable >::invoke </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Retrieve the reference. </p>
+<p>This is always a reference to the derived instance. </p><dl class="section return"><dt>Returns</dt><dd>The reference. </dd></dl>
+
+</div>
+</div>
+<a id="a41c17ef86e8c65998ba42097c7ad5f09"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a41c17ef86e8c65998ba42097c7ad5f09">◆ </a></span>visit()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type , bool I_derives_trackable = std::is_base_of<trackable, T_type>::value> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">const T_type& <a class="el" href="classsigc_1_1const__volatile__limit__reference.html">sigc::const_volatile_limit_reference</a>< T_type, I_derives_trackable >::visit </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Retrieve the entity to visit for <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each()</a>. </p>
+<p>Depending on the template specialization, this is either a derived reference, or <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>& if T_type derives from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>. </p><dl class="section return"><dt>Returns</dt><dd>The reference. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html">const_volatile_limit_reference< T_type, true ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::const_volatile_limit_reference< T_type, true > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html">sigc::const_volatile_limit_reference< T_type, true ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html#a94bf04779d798bd2737c521d20655122">const_volatile_limit_reference</a>(const T_type & _A_target)</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html">sigc::const_volatile_limit_reference< T_type, true ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html#a0a44e756c7478717ef8b34fb5b0c7004">invoke</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html">sigc::const_volatile_limit_reference< T_type, true ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html#a332d07b8ef0005163f02df234f014814">visit</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html">sigc::const_volatile_limit_reference< T_type, true ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::const_volatile_limit_reference< T_type, true > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html">const_volatile_limit_reference< T_type, true ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::const_volatile_limit_reference< T_type, true > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1const__volatile__limit__reference.html" title="A const_volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that,...">const_volatile_limit_reference</a> object for a class that derives from trackable.
+ <a href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/limit_reference.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a94bf04779d798bd2737c521d20655122"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html#a94bf04779d798bd2737c521d20655122">const_volatile_limit_reference</a> (const T_type & _A_target)</td></tr>
+<tr class="memdesc:a94bf04779d798bd2737c521d20655122"><td class="mdescLeft"> </td><td class="mdescRight">Constructor. <a href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html#a94bf04779d798bd2737c521d20655122">More...</a><br /></td></tr>
+<tr class="separator:a94bf04779d798bd2737c521d20655122"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0a44e756c7478717ef8b34fb5b0c7004"><td class="memItemLeft" align="right" valign="top">const volatile T_type & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html#a0a44e756c7478717ef8b34fb5b0c7004">invoke</a> () const</td></tr>
+<tr class="memdesc:a0a44e756c7478717ef8b34fb5b0c7004"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the reference. <a href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html#a0a44e756c7478717ef8b34fb5b0c7004">More...</a><br /></td></tr>
+<tr class="separator:a0a44e756c7478717ef8b34fb5b0c7004"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a332d07b8ef0005163f02df234f014814"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html#a332d07b8ef0005163f02df234f014814">visit</a> () const</td></tr>
+<tr class="memdesc:a332d07b8ef0005163f02df234f014814"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the entity to visit for <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each()</a>. <a href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html#a332d07b8ef0005163f02df234f014814">More...</a><br /></td></tr>
+<tr class="separator:a332d07b8ef0005163f02df234f014814"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_type><br />
+class sigc::const_volatile_limit_reference< T_type, true ></h3>
+
+<p><a class="el" href="classsigc_1_1const__volatile__limit__reference.html" title="A const_volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that,...">const_volatile_limit_reference</a> object for a class that derives from trackable. </p>
+<ul>
+<li><em>T_type</em> The type of the reference. </li>
+</ul>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a94bf04779d798bd2737c521d20655122"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a94bf04779d798bd2737c521d20655122">◆ </a></span>const_volatile_limit_reference()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html">sigc::const_volatile_limit_reference</a>< T_type, true >::<a class="el" href="classsigc_1_1const__volatile__limit__reference.html">const_volatile_limit_reference</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_type & </td>
+ <td class="paramname"><em>_A_target</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_target</td><td>The reference to limit. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a0a44e756c7478717ef8b34fb5b0c7004"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0a44e756c7478717ef8b34fb5b0c7004">◆ </a></span>invoke()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">const volatile T_type& <a class="el" href="classsigc_1_1const__volatile__limit__reference.html">sigc::const_volatile_limit_reference</a>< T_type, true >::invoke </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Retrieve the reference. </p>
+<p>This is always a reference to the derived instance. </p><dl class="section return"><dt>Returns</dt><dd>The reference. </dd></dl>
+
+</div>
+</div>
+<a id="a332d07b8ef0005163f02df234f014814"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a332d07b8ef0005163f02df234f014814">◆ </a></span>visit()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">const <a class="el" href="structsigc_1_1trackable.html">trackable</a>& <a class="el" href="classsigc_1_1const__volatile__limit__reference.html">sigc::const_volatile_limit_reference</a>< T_type, true >::visit </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Retrieve the entity to visit for <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each()</a>. </p>
+<p>Depending on the template specialization, this is either a derived reference, or <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>& if T_type derives from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>. </p><dl class="section return"><dt>Returns</dt><dd>The reference. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">const_volatile_mem_functor0</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::const_volatile_mem_functor0< T_return, T_obj > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">sigc::const_volatile_mem_functor0< T_return, T_obj ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#a8eec4c4ff04b8d5ef7c184e853ea0486">const_volatile_mem_functor0</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">sigc::const_volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#ab20dd00a6c8908a8ebd7846985d71856">const_volatile_mem_functor0</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">sigc::const_volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#ae0f88c6683fb175845f5f804c2c04ec8">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">sigc::const_volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#a3247f7d0e3804ff455e0996b969f6c59">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">sigc::const_volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#a86005d47b02e980c90d135a636e21674">operator()</a>(const T_obj * _A_obj) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">sigc::const_volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#adfd64d64707c012329915edf19190772">operator()</a>(const T_obj & _A_obj) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">sigc::const_volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#ab8e419ef5ad21d6230a306cd7d910df9">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">sigc::const_volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::const_volatile_mem_functor0< T_return, T_obj > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">const_volatile_mem_functor0</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1const__volatile__mem__functor0-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::const_volatile_mem_functor0< T_return, T_obj > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html" title="const_volatile_mem_functor0 wraps const volatile methods with 0 argument(s).">const_volatile_mem_functor0</a> wraps const volatile methods with 0 argument(s).
+ <a href="classsigc_1_1const__volatile__mem__functor0.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::const_volatile_mem_functor0< T_return, T_obj >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1const__volatile__mem__functor0__inherit__graph.png" border="0" usemap="#asigc_1_1const__volatile__mem__functor0_3_01T__return_00_01T__obj_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1const__volatile__mem__functor0_3_01T__return_00_01T__obj_01_4_inherit__map" id="asigc_1_1const__volatile__mem__functor0_3_01T__return_00_01T__obj_01_4_inherit__map">
+<area shape="rect" title="const_volatile_mem_functor0 wraps const volatile methods with 0 argument(s)." alt="" coords="5,80,203,136"/>
+<area shape="rect" href="classsigc_1_1bound__const__volatile__mem__functor0.html" title="bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object..." alt="" coords="5,184,203,240"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a3247f7d0e3804ff455e0996b969f6c59"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#a3247f7d0e3804ff455e0996b969f6c59">function_type</a>) () const volatile</td></tr>
+<tr class="separator:a3247f7d0e3804ff455e0996b969f6c59"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab8e419ef5ad21d6230a306cd7d910df9"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#ab8e419ef5ad21d6230a306cd7d910df9">result_type</a></td></tr>
+<tr class="separator:ab8e419ef5ad21d6230a306cd7d910df9"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a8eec4c4ff04b8d5ef7c184e853ea0486"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#a8eec4c4ff04b8d5ef7c184e853ea0486">const_volatile_mem_functor0</a> ()</td></tr>
+<tr class="memdesc:a8eec4c4ff04b8d5ef7c184e853ea0486"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__volatile__mem__functor0.html#a8eec4c4ff04b8d5ef7c184e853ea0486">More...</a><br /></td></tr>
+<tr class="separator:a8eec4c4ff04b8d5ef7c184e853ea0486"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab20dd00a6c8908a8ebd7846985d71856"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#ab20dd00a6c8908a8ebd7846985d71856">const_volatile_mem_functor0</a> (<a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#a3247f7d0e3804ff455e0996b969f6c59">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:ab20dd00a6c8908a8ebd7846985d71856"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html" title="const_volatile_mem_functor0 wraps const volatile methods with 0 argument(s).">const_volatile_mem_functor0</a> object that wraps the passed method. <a href="classsigc_1_1const__volatile__mem__functor0.html#ab20dd00a6c8908a8ebd7846985d71856">More...</a><br /></td></tr>
+<tr class="separator:ab20dd00a6c8908a8ebd7846985d71856"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adfd64d64707c012329915edf19190772"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#adfd64d64707c012329915edf19190772">operator()</a> (const T_obj & _A_obj) const</td></tr>
+<tr class="memdesc:adfd64d64707c012329915edf19190772"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor0.html#adfd64d64707c012329915edf19190772">More...</a><br /></td></tr>
+<tr class="separator:adfd64d64707c012329915edf19190772"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a86005d47b02e980c90d135a636e21674"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#a86005d47b02e980c90d135a636e21674">operator()</a> (const T_obj * _A_obj) const</td></tr>
+<tr class="memdesc:a86005d47b02e980c90d135a636e21674"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor0.html#a86005d47b02e980c90d135a636e21674">More...</a><br /></td></tr>
+<tr class="separator:a86005d47b02e980c90d135a636e21674"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:ae0f88c6683fb175845f5f804c2c04ec8"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#a3247f7d0e3804ff455e0996b969f6c59">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#ae0f88c6683fb175845f5f804c2c04ec8">func_ptr_</a></td></tr>
+<tr class="separator:ae0f88c6683fb175845f5f804c2c04ec8"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj><br />
+class sigc::const_volatile_mem_functor0< T_return, T_obj ></h3>
+
+<p><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html" title="const_volatile_mem_functor0 wraps const volatile methods with 0 argument(s).">const_volatile_mem_functor0</a> wraps const volatile methods with 0 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html" title="const_volatile_mem_functor0 wraps const volatile methods with 0 argument(s).">const_volatile_mem_functor0</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#a86005d47b02e980c90d135a636e21674" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a3247f7d0e3804ff455e0996b969f6c59"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3247f7d0e3804ff455e0996b969f6c59">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">sigc::const_volatile_mem_functor0</a>< T_return, T_obj >::function_type) () const volatile</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ab8e419ef5ad21d6230a306cd7d910df9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab8e419ef5ad21d6230a306cd7d910df9">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">sigc::const_volatile_mem_functor0</a>< T_return, T_obj >::<a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#ab8e419ef5ad21d6230a306cd7d910df9">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a8eec4c4ff04b8d5ef7c184e853ea0486"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8eec4c4ff04b8d5ef7c184e853ea0486">◆ </a></span>const_volatile_mem_functor0() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">sigc::const_volatile_mem_functor0</a>< T_return, T_obj >::<a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">const_volatile_mem_functor0</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="ab20dd00a6c8908a8ebd7846985d71856"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab20dd00a6c8908a8ebd7846985d71856">◆ </a></span>const_volatile_mem_functor0() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">sigc::const_volatile_mem_functor0</a>< T_return, T_obj >::<a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">const_volatile_mem_functor0</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#a3247f7d0e3804ff455e0996b969f6c59">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html" title="const_volatile_mem_functor0 wraps const volatile methods with 0 argument(s).">const_volatile_mem_functor0</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#a86005d47b02e980c90d135a636e21674" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="adfd64d64707c012329915edf19190772"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#adfd64d64707c012329915edf19190772">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">sigc::const_volatile_mem_functor0</a>< T_return, T_obj >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a86005d47b02e980c90d135a636e21674"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a86005d47b02e980c90d135a636e21674">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">sigc::const_volatile_mem_functor0</a>< T_return, T_obj >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000154">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="ae0f88c6683fb175845f5f804c2c04ec8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae0f88c6683fb175845f5f804c2c04ec8">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#a3247f7d0e3804ff455e0996b969f6c59">function_type</a> <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">sigc::const_volatile_mem_functor0</a>< T_return, T_obj >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::const_volatile_mem_functor0< T_return, T_obj >" name="sigc::const_volatile_mem_functor0< T_return, T_obj >">
+<area shape="rect" id="node1" title="const_volatile_mem_functor0 wraps const volatile methods with 0 argument(s)." alt="" coords="5,80,203,136"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__const__volatile__mem__functor0.html" title="bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object..." alt="" coords="5,184,203,240"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
--- /dev/null
+2bebbb69ce91c119757da308ecab635d
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">const_volatile_mem_functor1</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#a25a541c4bef874a6b2d177a3be7ab988">const_volatile_mem_functor1</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#aa8cb4ad934ac610ffe3425cbe799ba8d">const_volatile_mem_functor1</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#af9da27522999030f09c718dbe164f1f6">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#acc367f8d6ee646c370623650a7ed6cde">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#a9af06968e1db65f5bd136175e10d250f">operator()</a>(const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#a715b1d5c56a537cbd397875e8eba532d">operator()</a>(const T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#adeaf82cc2aff607efe2a51945d6b8565">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">const_volatile_mem_functor1</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1const__volatile__mem__functor1-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html" title="const_volatile_mem_functor1 wraps const volatile methods with 1 argument(s).">const_volatile_mem_functor1</a> wraps const volatile methods with 1 argument(s).
+ <a href="classsigc_1_1const__volatile__mem__functor1.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1const__volatile__mem__functor1__inherit__graph.png" border="0" usemap="#asigc_1_1const__volatile__mem__functor1_3_01T__return_00_01T__obj_00_01T__arg1_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1const__volatile__mem__functor1_3_01T__return_00_01T__obj_00_01T__arg1_01_4_inherit__map" id="asigc_1_1const__volatile__mem__functor1_3_01T__return_00_01T__obj_00_01T__arg1_01_4_inherit__map">
+<area shape="rect" title="const_volatile_mem_functor1 wraps const volatile methods with 1 argument(s)." alt="" coords="5,80,203,136"/>
+<area shape="rect" href="classsigc_1_1bound__const__volatile__mem__functor1.html" title="bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object..." alt="" coords="5,184,203,240"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:acc367f8d6ee646c370623650a7ed6cde"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#acc367f8d6ee646c370623650a7ed6cde">function_type</a>) (T_arg1) const volatile</td></tr>
+<tr class="separator:acc367f8d6ee646c370623650a7ed6cde"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adeaf82cc2aff607efe2a51945d6b8565"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#adeaf82cc2aff607efe2a51945d6b8565">result_type</a></td></tr>
+<tr class="separator:adeaf82cc2aff607efe2a51945d6b8565"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a25a541c4bef874a6b2d177a3be7ab988"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#a25a541c4bef874a6b2d177a3be7ab988">const_volatile_mem_functor1</a> ()</td></tr>
+<tr class="memdesc:a25a541c4bef874a6b2d177a3be7ab988"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__volatile__mem__functor1.html#a25a541c4bef874a6b2d177a3be7ab988">More...</a><br /></td></tr>
+<tr class="separator:a25a541c4bef874a6b2d177a3be7ab988"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa8cb4ad934ac610ffe3425cbe799ba8d"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#aa8cb4ad934ac610ffe3425cbe799ba8d">const_volatile_mem_functor1</a> (<a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#acc367f8d6ee646c370623650a7ed6cde">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:aa8cb4ad934ac610ffe3425cbe799ba8d"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html" title="const_volatile_mem_functor1 wraps const volatile methods with 1 argument(s).">const_volatile_mem_functor1</a> object that wraps the passed method. <a href="classsigc_1_1const__volatile__mem__functor1.html#aa8cb4ad934ac610ffe3425cbe799ba8d">More...</a><br /></td></tr>
+<tr class="separator:aa8cb4ad934ac610ffe3425cbe799ba8d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a715b1d5c56a537cbd397875e8eba532d"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#a715b1d5c56a537cbd397875e8eba532d">operator()</a> (const T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a715b1d5c56a537cbd397875e8eba532d"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor1.html#a715b1d5c56a537cbd397875e8eba532d">More...</a><br /></td></tr>
+<tr class="separator:a715b1d5c56a537cbd397875e8eba532d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9af06968e1db65f5bd136175e10d250f"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#a9af06968e1db65f5bd136175e10d250f">operator()</a> (const T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a9af06968e1db65f5bd136175e10d250f"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor1.html#a9af06968e1db65f5bd136175e10d250f">More...</a><br /></td></tr>
+<tr class="separator:a9af06968e1db65f5bd136175e10d250f"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:af9da27522999030f09c718dbe164f1f6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#acc367f8d6ee646c370623650a7ed6cde">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#af9da27522999030f09c718dbe164f1f6">func_ptr_</a></td></tr>
+<tr class="separator:af9da27522999030f09c718dbe164f1f6"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1><br />
+class sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></h3>
+
+<p><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html" title="const_volatile_mem_functor1 wraps const volatile methods with 1 argument(s).">const_volatile_mem_functor1</a> wraps const volatile methods with 1 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html" title="const_volatile_mem_functor1 wraps const volatile methods with 1 argument(s).">const_volatile_mem_functor1</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#a9af06968e1db65f5bd136175e10d250f" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#a9af06968e1db65f5bd136175e10d250f" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="acc367f8d6ee646c370623650a7ed6cde"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#acc367f8d6ee646c370623650a7ed6cde">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">sigc::const_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >::function_type) (T_arg1) const volatile</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="adeaf82cc2aff607efe2a51945d6b8565"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#adeaf82cc2aff607efe2a51945d6b8565">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">sigc::const_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >::<a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#adeaf82cc2aff607efe2a51945d6b8565">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a25a541c4bef874a6b2d177a3be7ab988"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a25a541c4bef874a6b2d177a3be7ab988">◆ </a></span>const_volatile_mem_functor1() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">sigc::const_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >::<a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">const_volatile_mem_functor1</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="aa8cb4ad934ac610ffe3425cbe799ba8d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa8cb4ad934ac610ffe3425cbe799ba8d">◆ </a></span>const_volatile_mem_functor1() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">sigc::const_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >::<a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">const_volatile_mem_functor1</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#acc367f8d6ee646c370623650a7ed6cde">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html" title="const_volatile_mem_functor1 wraps const volatile methods with 1 argument(s).">const_volatile_mem_functor1</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#a9af06968e1db65f5bd136175e10d250f" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a715b1d5c56a537cbd397875e8eba532d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a715b1d5c56a537cbd397875e8eba532d">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">sigc::const_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a9af06968e1db65f5bd136175e10d250f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9af06968e1db65f5bd136175e10d250f">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">sigc::const_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000155">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="af9da27522999030f09c718dbe164f1f6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af9da27522999030f09c718dbe164f1f6">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#acc367f8d6ee646c370623650a7ed6cde">function_type</a> <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">sigc::const_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 >" name="sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 >">
+<area shape="rect" id="node1" title="const_volatile_mem_functor1 wraps const volatile methods with 1 argument(s)." alt="" coords="5,80,203,136"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__const__volatile__mem__functor1.html" title="bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object..." alt="" coords="5,184,203,240"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
--- /dev/null
+4adb06df80f7ee666ab06ba6b7293432
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">const_volatile_mem_functor2</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#ad99060cf675fb65cbc00f2b8e9ec3068">const_volatile_mem_functor2</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#ada3da9a8dd692377c90abbfa9bcfe73a">const_volatile_mem_functor2</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#aac7f64e6cff784ecd6700d0448d8e796">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#ac46d1e343e669092d6bb24aa8b5d5dbb">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#a9d024cf10df876df77183e1fb79a52ec">operator()</a>(const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#a467a45cf9bc54bed0f3c5bade3329067">operator()</a>(const T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#a0d143bb32627f7a0c17270321df8145f">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">const_volatile_mem_functor2</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1const__volatile__mem__functor2-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html" title="const_volatile_mem_functor2 wraps const volatile methods with 2 argument(s).">const_volatile_mem_functor2</a> wraps const volatile methods with 2 argument(s).
+ <a href="classsigc_1_1const__volatile__mem__functor2.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1const__volatile__mem__functor2__inherit__graph.png" border="0" usemap="#asigc_1_1const__volatile__mem__functor2_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1const__volatile__mem__functor2_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_01_4_inherit__map" id="asigc_1_1const__volatile__mem__functor2_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_01_4_inherit__map">
+<area shape="rect" title="const_volatile_mem_functor2 wraps const volatile methods with 2 argument(s)." alt="" coords="5,80,203,136"/>
+<area shape="rect" href="classsigc_1_1bound__const__volatile__mem__functor2.html" title="bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object..." alt="" coords="5,184,203,240"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:ac46d1e343e669092d6bb24aa8b5d5dbb"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#ac46d1e343e669092d6bb24aa8b5d5dbb">function_type</a>) (T_arg1, T_arg2) const volatile</td></tr>
+<tr class="separator:ac46d1e343e669092d6bb24aa8b5d5dbb"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0d143bb32627f7a0c17270321df8145f"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#a0d143bb32627f7a0c17270321df8145f">result_type</a></td></tr>
+<tr class="separator:a0d143bb32627f7a0c17270321df8145f"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:ad99060cf675fb65cbc00f2b8e9ec3068"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#ad99060cf675fb65cbc00f2b8e9ec3068">const_volatile_mem_functor2</a> ()</td></tr>
+<tr class="memdesc:ad99060cf675fb65cbc00f2b8e9ec3068"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__volatile__mem__functor2.html#ad99060cf675fb65cbc00f2b8e9ec3068">More...</a><br /></td></tr>
+<tr class="separator:ad99060cf675fb65cbc00f2b8e9ec3068"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ada3da9a8dd692377c90abbfa9bcfe73a"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#ada3da9a8dd692377c90abbfa9bcfe73a">const_volatile_mem_functor2</a> (<a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#ac46d1e343e669092d6bb24aa8b5d5dbb">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:ada3da9a8dd692377c90abbfa9bcfe73a"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html" title="const_volatile_mem_functor2 wraps const volatile methods with 2 argument(s).">const_volatile_mem_functor2</a> object that wraps the passed method. <a href="classsigc_1_1const__volatile__mem__functor2.html#ada3da9a8dd692377c90abbfa9bcfe73a">More...</a><br /></td></tr>
+<tr class="separator:ada3da9a8dd692377c90abbfa9bcfe73a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a467a45cf9bc54bed0f3c5bade3329067"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#a467a45cf9bc54bed0f3c5bade3329067">operator()</a> (const T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:a467a45cf9bc54bed0f3c5bade3329067"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor2.html#a467a45cf9bc54bed0f3c5bade3329067">More...</a><br /></td></tr>
+<tr class="separator:a467a45cf9bc54bed0f3c5bade3329067"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9d024cf10df876df77183e1fb79a52ec"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#a9d024cf10df876df77183e1fb79a52ec">operator()</a> (const T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:a9d024cf10df876df77183e1fb79a52ec"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor2.html#a9d024cf10df876df77183e1fb79a52ec">More...</a><br /></td></tr>
+<tr class="separator:a9d024cf10df876df77183e1fb79a52ec"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:aac7f64e6cff784ecd6700d0448d8e796"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#ac46d1e343e669092d6bb24aa8b5d5dbb">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#aac7f64e6cff784ecd6700d0448d8e796">func_ptr_</a></td></tr>
+<tr class="separator:aac7f64e6cff784ecd6700d0448d8e796"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2><br />
+class sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></h3>
+
+<p><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html" title="const_volatile_mem_functor2 wraps const volatile methods with 2 argument(s).">const_volatile_mem_functor2</a> wraps const volatile methods with 2 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html" title="const_volatile_mem_functor2 wraps const volatile methods with 2 argument(s).">const_volatile_mem_functor2</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#a9d024cf10df876df77183e1fb79a52ec" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#a9d024cf10df876df77183e1fb79a52ec" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#a9d024cf10df876df77183e1fb79a52ec" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="ac46d1e343e669092d6bb24aa8b5d5dbb"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac46d1e343e669092d6bb24aa8b5d5dbb">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">sigc::const_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::function_type) (T_arg1, T_arg2) const volatile</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a0d143bb32627f7a0c17270321df8145f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0d143bb32627f7a0c17270321df8145f">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">sigc::const_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#a0d143bb32627f7a0c17270321df8145f">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="ad99060cf675fb65cbc00f2b8e9ec3068"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad99060cf675fb65cbc00f2b8e9ec3068">◆ </a></span>const_volatile_mem_functor2() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">sigc::const_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">const_volatile_mem_functor2</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="ada3da9a8dd692377c90abbfa9bcfe73a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ada3da9a8dd692377c90abbfa9bcfe73a">◆ </a></span>const_volatile_mem_functor2() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">sigc::const_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">const_volatile_mem_functor2</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#ac46d1e343e669092d6bb24aa8b5d5dbb">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html" title="const_volatile_mem_functor2 wraps const volatile methods with 2 argument(s).">const_volatile_mem_functor2</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#a9d024cf10df876df77183e1fb79a52ec" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a467a45cf9bc54bed0f3c5bade3329067"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a467a45cf9bc54bed0f3c5bade3329067">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">sigc::const_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a9d024cf10df876df77183e1fb79a52ec"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9d024cf10df876df77183e1fb79a52ec">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">sigc::const_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000156">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="aac7f64e6cff784ecd6700d0448d8e796"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aac7f64e6cff784ecd6700d0448d8e796">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#ac46d1e343e669092d6bb24aa8b5d5dbb">function_type</a> <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">sigc::const_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >" name="sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >">
+<area shape="rect" id="node1" title="const_volatile_mem_functor2 wraps const volatile methods with 2 argument(s)." alt="" coords="5,80,203,136"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__const__volatile__mem__functor2.html" title="bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object..." alt="" coords="5,184,203,240"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
--- /dev/null
+5fd76924da675d9c55e7ed67207c05ad
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">const_volatile_mem_functor3</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#af284f300a6b3696f6379dcc9ed97a744">const_volatile_mem_functor3</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#aa586f24064b6a5c8b69c963fff614d04">const_volatile_mem_functor3</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a6ffedac451ab4f525bd7c9df0b83cf2c">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a472ab7835e2b6792a108f4fcc80d4669">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a47374a80a3a61b69e39478ca9a4a4776">operator()</a>(const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a4af918f707067763bb2031d8758991d5">operator()</a>(const T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#ad2056f73eed4664ff41f5e673a2276f0">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">const_volatile_mem_functor3</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1const__volatile__mem__functor3-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html" title="const_volatile_mem_functor3 wraps const volatile methods with 3 argument(s).">const_volatile_mem_functor3</a> wraps const volatile methods with 3 argument(s).
+ <a href="classsigc_1_1const__volatile__mem__functor3.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1const__volatile__mem__functor3__inherit__graph.png" border="0" usemap="#asigc_1_1const__volatile__mem__functor3_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1const__volatile__mem__functor3_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_01_4_inherit__map" id="asigc_1_1const__volatile__mem__functor3_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_01_4_inherit__map">
+<area shape="rect" title="const_volatile_mem_functor3 wraps const volatile methods with 3 argument(s)." alt="" coords="193,5,391,76"/>
+<area shape="rect" href="classsigc_1_1bound__const__volatile__mem__functor3.html" title="bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object..." alt="" coords="439,13,671,69"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,27,145,54"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a472ab7835e2b6792a108f4fcc80d4669"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a472ab7835e2b6792a108f4fcc80d4669">function_type</a>) (T_arg1, T_arg2, T_arg3) const volatile</td></tr>
+<tr class="separator:a472ab7835e2b6792a108f4fcc80d4669"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad2056f73eed4664ff41f5e673a2276f0"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#ad2056f73eed4664ff41f5e673a2276f0">result_type</a></td></tr>
+<tr class="separator:ad2056f73eed4664ff41f5e673a2276f0"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:af284f300a6b3696f6379dcc9ed97a744"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#af284f300a6b3696f6379dcc9ed97a744">const_volatile_mem_functor3</a> ()</td></tr>
+<tr class="memdesc:af284f300a6b3696f6379dcc9ed97a744"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__volatile__mem__functor3.html#af284f300a6b3696f6379dcc9ed97a744">More...</a><br /></td></tr>
+<tr class="separator:af284f300a6b3696f6379dcc9ed97a744"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa586f24064b6a5c8b69c963fff614d04"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#aa586f24064b6a5c8b69c963fff614d04">const_volatile_mem_functor3</a> (<a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a472ab7835e2b6792a108f4fcc80d4669">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:aa586f24064b6a5c8b69c963fff614d04"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html" title="const_volatile_mem_functor3 wraps const volatile methods with 3 argument(s).">const_volatile_mem_functor3</a> object that wraps the passed method. <a href="classsigc_1_1const__volatile__mem__functor3.html#aa586f24064b6a5c8b69c963fff614d04">More...</a><br /></td></tr>
+<tr class="separator:aa586f24064b6a5c8b69c963fff614d04"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4af918f707067763bb2031d8758991d5"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a4af918f707067763bb2031d8758991d5">operator()</a> (const T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:a4af918f707067763bb2031d8758991d5"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor3.html#a4af918f707067763bb2031d8758991d5">More...</a><br /></td></tr>
+<tr class="separator:a4af918f707067763bb2031d8758991d5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a47374a80a3a61b69e39478ca9a4a4776"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a47374a80a3a61b69e39478ca9a4a4776">operator()</a> (const T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:a47374a80a3a61b69e39478ca9a4a4776"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor3.html#a47374a80a3a61b69e39478ca9a4a4776">More...</a><br /></td></tr>
+<tr class="separator:a47374a80a3a61b69e39478ca9a4a4776"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:a6ffedac451ab4f525bd7c9df0b83cf2c"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a472ab7835e2b6792a108f4fcc80d4669">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a6ffedac451ab4f525bd7c9df0b83cf2c">func_ptr_</a></td></tr>
+<tr class="separator:a6ffedac451ab4f525bd7c9df0b83cf2c"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3><br />
+class sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></h3>
+
+<p><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html" title="const_volatile_mem_functor3 wraps const volatile methods with 3 argument(s).">const_volatile_mem_functor3</a> wraps const volatile methods with 3 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html" title="const_volatile_mem_functor3 wraps const volatile methods with 3 argument(s).">const_volatile_mem_functor3</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a47374a80a3a61b69e39478ca9a4a4776" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a47374a80a3a61b69e39478ca9a4a4776" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a47374a80a3a61b69e39478ca9a4a4776" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a47374a80a3a61b69e39478ca9a4a4776" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a472ab7835e2b6792a108f4fcc80d4669"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a472ab7835e2b6792a108f4fcc80d4669">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">sigc::const_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::function_type) (T_arg1, T_arg2, T_arg3) const volatile</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ad2056f73eed4664ff41f5e673a2276f0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad2056f73eed4664ff41f5e673a2276f0">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">sigc::const_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#ad2056f73eed4664ff41f5e673a2276f0">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="af284f300a6b3696f6379dcc9ed97a744"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af284f300a6b3696f6379dcc9ed97a744">◆ </a></span>const_volatile_mem_functor3() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">sigc::const_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">const_volatile_mem_functor3</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="aa586f24064b6a5c8b69c963fff614d04"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa586f24064b6a5c8b69c963fff614d04">◆ </a></span>const_volatile_mem_functor3() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">sigc::const_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">const_volatile_mem_functor3</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a472ab7835e2b6792a108f4fcc80d4669">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html" title="const_volatile_mem_functor3 wraps const volatile methods with 3 argument(s).">const_volatile_mem_functor3</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a47374a80a3a61b69e39478ca9a4a4776" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a4af918f707067763bb2031d8758991d5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4af918f707067763bb2031d8758991d5">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">sigc::const_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a47374a80a3a61b69e39478ca9a4a4776"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a47374a80a3a61b69e39478ca9a4a4776">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">sigc::const_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000157">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a6ffedac451ab4f525bd7c9df0b83cf2c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a6ffedac451ab4f525bd7c9df0b83cf2c">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a472ab7835e2b6792a108f4fcc80d4669">function_type</a> <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">sigc::const_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >" name="sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >">
+<area shape="rect" id="node1" title="const_volatile_mem_functor3 wraps const volatile methods with 3 argument(s)." alt="" coords="193,5,391,76"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__const__volatile__mem__functor3.html" title="bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object..." alt="" coords="439,13,671,69"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,27,145,54"/>
+</map>
--- /dev/null
+1d929c3c6f692cc5e29fe55b1c973036
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">const_volatile_mem_functor4</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#aad7b7f5037a0c8d13668f9c350e010ee">const_volatile_mem_functor4</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a0ffe59d6392c736e6d14c43a4bfa26e5">const_volatile_mem_functor4</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a0714aabc799c5d41af988650fec71410">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#ace3cb54e6265ebe06ee2995dd01f2540">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a589c68eddffeb3399838d2af7f5b6d19">operator()</a>(const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a7cd0900e7e3c8523503e037e7c696f5d">operator()</a>(const T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a8e38a0816627c7ad4fd48278d287f863">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">const_volatile_mem_functor4</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1const__volatile__mem__functor4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html" title="const_volatile_mem_functor4 wraps const volatile methods with 4 argument(s).">const_volatile_mem_functor4</a> wraps const volatile methods with 4 argument(s).
+ <a href="classsigc_1_1const__volatile__mem__functor4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1const__volatile__mem__functor4__inherit__graph.png" border="0" usemap="#asigc_1_1const__volatile__mem__functor4_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1const__volatile__mem__functor4_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_01_4_inherit__map" id="asigc_1_1const__volatile__mem__functor4_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_01_4_inherit__map">
+<area shape="rect" title="const_volatile_mem_functor4 wraps const volatile methods with 4 argument(s)." alt="" coords="193,5,391,76"/>
+<area shape="rect" href="classsigc_1_1bound__const__volatile__mem__functor4.html" title="bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object..." alt="" coords="439,5,636,76"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,27,145,54"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:ace3cb54e6265ebe06ee2995dd01f2540"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#ace3cb54e6265ebe06ee2995dd01f2540">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4) const volatile</td></tr>
+<tr class="separator:ace3cb54e6265ebe06ee2995dd01f2540"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8e38a0816627c7ad4fd48278d287f863"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a8e38a0816627c7ad4fd48278d287f863">result_type</a></td></tr>
+<tr class="separator:a8e38a0816627c7ad4fd48278d287f863"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:aad7b7f5037a0c8d13668f9c350e010ee"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#aad7b7f5037a0c8d13668f9c350e010ee">const_volatile_mem_functor4</a> ()</td></tr>
+<tr class="memdesc:aad7b7f5037a0c8d13668f9c350e010ee"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__volatile__mem__functor4.html#aad7b7f5037a0c8d13668f9c350e010ee">More...</a><br /></td></tr>
+<tr class="separator:aad7b7f5037a0c8d13668f9c350e010ee"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0ffe59d6392c736e6d14c43a4bfa26e5"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a0ffe59d6392c736e6d14c43a4bfa26e5">const_volatile_mem_functor4</a> (<a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#ace3cb54e6265ebe06ee2995dd01f2540">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a0ffe59d6392c736e6d14c43a4bfa26e5"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html" title="const_volatile_mem_functor4 wraps const volatile methods with 4 argument(s).">const_volatile_mem_functor4</a> object that wraps the passed method. <a href="classsigc_1_1const__volatile__mem__functor4.html#a0ffe59d6392c736e6d14c43a4bfa26e5">More...</a><br /></td></tr>
+<tr class="separator:a0ffe59d6392c736e6d14c43a4bfa26e5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7cd0900e7e3c8523503e037e7c696f5d"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a7cd0900e7e3c8523503e037e7c696f5d">operator()</a> (const T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:a7cd0900e7e3c8523503e037e7c696f5d"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor4.html#a7cd0900e7e3c8523503e037e7c696f5d">More...</a><br /></td></tr>
+<tr class="separator:a7cd0900e7e3c8523503e037e7c696f5d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a589c68eddffeb3399838d2af7f5b6d19"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a589c68eddffeb3399838d2af7f5b6d19">operator()</a> (const T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:a589c68eddffeb3399838d2af7f5b6d19"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor4.html#a589c68eddffeb3399838d2af7f5b6d19">More...</a><br /></td></tr>
+<tr class="separator:a589c68eddffeb3399838d2af7f5b6d19"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:a0714aabc799c5d41af988650fec71410"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#ace3cb54e6265ebe06ee2995dd01f2540">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a0714aabc799c5d41af988650fec71410">func_ptr_</a></td></tr>
+<tr class="separator:a0714aabc799c5d41af988650fec71410"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4><br />
+class sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></h3>
+
+<p><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html" title="const_volatile_mem_functor4 wraps const volatile methods with 4 argument(s).">const_volatile_mem_functor4</a> wraps const volatile methods with 4 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html" title="const_volatile_mem_functor4 wraps const volatile methods with 4 argument(s).">const_volatile_mem_functor4</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a589c68eddffeb3399838d2af7f5b6d19" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a589c68eddffeb3399838d2af7f5b6d19" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a589c68eddffeb3399838d2af7f5b6d19" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a589c68eddffeb3399838d2af7f5b6d19" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a589c68eddffeb3399838d2af7f5b6d19" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="ace3cb54e6265ebe06ee2995dd01f2540"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ace3cb54e6265ebe06ee2995dd01f2540">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">sigc::const_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::function_type) (T_arg1, T_arg2, T_arg3, T_arg4) const volatile</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a8e38a0816627c7ad4fd48278d287f863"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8e38a0816627c7ad4fd48278d287f863">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">sigc::const_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a8e38a0816627c7ad4fd48278d287f863">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="aad7b7f5037a0c8d13668f9c350e010ee"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aad7b7f5037a0c8d13668f9c350e010ee">◆ </a></span>const_volatile_mem_functor4() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">sigc::const_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">const_volatile_mem_functor4</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="a0ffe59d6392c736e6d14c43a4bfa26e5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0ffe59d6392c736e6d14c43a4bfa26e5">◆ </a></span>const_volatile_mem_functor4() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">sigc::const_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">const_volatile_mem_functor4</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#ace3cb54e6265ebe06ee2995dd01f2540">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html" title="const_volatile_mem_functor4 wraps const volatile methods with 4 argument(s).">const_volatile_mem_functor4</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a589c68eddffeb3399838d2af7f5b6d19" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a7cd0900e7e3c8523503e037e7c696f5d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7cd0900e7e3c8523503e037e7c696f5d">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">sigc::const_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a589c68eddffeb3399838d2af7f5b6d19"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a589c68eddffeb3399838d2af7f5b6d19">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">sigc::const_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000158">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a0714aabc799c5d41af988650fec71410"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0714aabc799c5d41af988650fec71410">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#ace3cb54e6265ebe06ee2995dd01f2540">function_type</a> <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">sigc::const_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >" name="sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >">
+<area shape="rect" id="node1" title="const_volatile_mem_functor4 wraps const volatile methods with 4 argument(s)." alt="" coords="193,5,391,76"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__const__volatile__mem__functor4.html" title="bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object..." alt="" coords="439,5,636,76"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,27,145,54"/>
+</map>
--- /dev/null
+777da39091931d385692c3d57ba97f75
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">const_volatile_mem_functor5</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#afe48307086c70740f39f58488a3cbdb5">const_volatile_mem_functor5</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a13787a099e237b44280ddbe9b8d97a04">const_volatile_mem_functor5</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a785d079f14f42cafd052639a1ebdaeb9">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a1d49a5a7086d41d1db2e40aed1273631">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a7b1fde7647e7e936b29c97797835ca7b">operator()</a>(const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a8d74b334440d1c9add3a358cd1913b11">operator()</a>(const T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a42d6cd140b98358c1d12c90b975ad2b1">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">const_volatile_mem_functor5</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1const__volatile__mem__functor5-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html" title="const_volatile_mem_functor5 wraps const volatile methods with 5 argument(s).">const_volatile_mem_functor5</a> wraps const volatile methods with 5 argument(s).
+ <a href="classsigc_1_1const__volatile__mem__functor5.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1const__volatile__mem__functor5__inherit__graph.png" border="0" usemap="#asigc_1_1const__volatile__mem__functor5_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1const__volatile__mem__functor5_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_01_4_inherit__map" id="asigc_1_1const__volatile__mem__functor5_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_01_4_inherit__map">
+<area shape="rect" title="const_volatile_mem_functor5 wraps const volatile methods with 5 argument(s)." alt="" coords="193,5,391,76"/>
+<area shape="rect" href="classsigc_1_1bound__const__volatile__mem__functor5.html" title="bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object..." alt="" coords="439,5,636,76"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,27,145,54"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a1d49a5a7086d41d1db2e40aed1273631"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a1d49a5a7086d41d1db2e40aed1273631">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile</td></tr>
+<tr class="separator:a1d49a5a7086d41d1db2e40aed1273631"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a42d6cd140b98358c1d12c90b975ad2b1"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a42d6cd140b98358c1d12c90b975ad2b1">result_type</a></td></tr>
+<tr class="separator:a42d6cd140b98358c1d12c90b975ad2b1"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:afe48307086c70740f39f58488a3cbdb5"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#afe48307086c70740f39f58488a3cbdb5">const_volatile_mem_functor5</a> ()</td></tr>
+<tr class="memdesc:afe48307086c70740f39f58488a3cbdb5"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__volatile__mem__functor5.html#afe48307086c70740f39f58488a3cbdb5">More...</a><br /></td></tr>
+<tr class="separator:afe48307086c70740f39f58488a3cbdb5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a13787a099e237b44280ddbe9b8d97a04"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a13787a099e237b44280ddbe9b8d97a04">const_volatile_mem_functor5</a> (<a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a1d49a5a7086d41d1db2e40aed1273631">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a13787a099e237b44280ddbe9b8d97a04"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html" title="const_volatile_mem_functor5 wraps const volatile methods with 5 argument(s).">const_volatile_mem_functor5</a> object that wraps the passed method. <a href="classsigc_1_1const__volatile__mem__functor5.html#a13787a099e237b44280ddbe9b8d97a04">More...</a><br /></td></tr>
+<tr class="separator:a13787a099e237b44280ddbe9b8d97a04"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8d74b334440d1c9add3a358cd1913b11"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a8d74b334440d1c9add3a358cd1913b11">operator()</a> (const T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:a8d74b334440d1c9add3a358cd1913b11"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor5.html#a8d74b334440d1c9add3a358cd1913b11">More...</a><br /></td></tr>
+<tr class="separator:a8d74b334440d1c9add3a358cd1913b11"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7b1fde7647e7e936b29c97797835ca7b"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a7b1fde7647e7e936b29c97797835ca7b">operator()</a> (const T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:a7b1fde7647e7e936b29c97797835ca7b"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor5.html#a7b1fde7647e7e936b29c97797835ca7b">More...</a><br /></td></tr>
+<tr class="separator:a7b1fde7647e7e936b29c97797835ca7b"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:a785d079f14f42cafd052639a1ebdaeb9"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a1d49a5a7086d41d1db2e40aed1273631">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a785d079f14f42cafd052639a1ebdaeb9">func_ptr_</a></td></tr>
+<tr class="separator:a785d079f14f42cafd052639a1ebdaeb9"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5><br />
+class sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></h3>
+
+<p><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html" title="const_volatile_mem_functor5 wraps const volatile methods with 5 argument(s).">const_volatile_mem_functor5</a> wraps const volatile methods with 5 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html" title="const_volatile_mem_functor5 wraps const volatile methods with 5 argument(s).">const_volatile_mem_functor5</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a7b1fde7647e7e936b29c97797835ca7b" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a7b1fde7647e7e936b29c97797835ca7b" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a7b1fde7647e7e936b29c97797835ca7b" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a7b1fde7647e7e936b29c97797835ca7b" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a7b1fde7647e7e936b29c97797835ca7b" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a7b1fde7647e7e936b29c97797835ca7b" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a1d49a5a7086d41d1db2e40aed1273631"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1d49a5a7086d41d1db2e40aed1273631">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">sigc::const_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::function_type) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a42d6cd140b98358c1d12c90b975ad2b1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a42d6cd140b98358c1d12c90b975ad2b1">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">sigc::const_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a42d6cd140b98358c1d12c90b975ad2b1">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="afe48307086c70740f39f58488a3cbdb5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#afe48307086c70740f39f58488a3cbdb5">◆ </a></span>const_volatile_mem_functor5() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">sigc::const_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">const_volatile_mem_functor5</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="a13787a099e237b44280ddbe9b8d97a04"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a13787a099e237b44280ddbe9b8d97a04">◆ </a></span>const_volatile_mem_functor5() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">sigc::const_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">const_volatile_mem_functor5</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a1d49a5a7086d41d1db2e40aed1273631">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html" title="const_volatile_mem_functor5 wraps const volatile methods with 5 argument(s).">const_volatile_mem_functor5</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a7b1fde7647e7e936b29c97797835ca7b" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a8d74b334440d1c9add3a358cd1913b11"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8d74b334440d1c9add3a358cd1913b11">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">sigc::const_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a7b1fde7647e7e936b29c97797835ca7b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7b1fde7647e7e936b29c97797835ca7b">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">sigc::const_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000159">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a785d079f14f42cafd052639a1ebdaeb9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a785d079f14f42cafd052639a1ebdaeb9">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a1d49a5a7086d41d1db2e40aed1273631">function_type</a> <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">sigc::const_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >" name="sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >">
+<area shape="rect" id="node1" title="const_volatile_mem_functor5 wraps const volatile methods with 5 argument(s)." alt="" coords="193,5,391,76"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__const__volatile__mem__functor5.html" title="bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object..." alt="" coords="439,5,636,76"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,27,145,54"/>
+</map>
--- /dev/null
+eca2455c5d9a41b37111dc1b659e2841
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">const_volatile_mem_functor6</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#aa921f2d1cea8ddd987cdaa8df6479fab">const_volatile_mem_functor6</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#a09704c72e9b0353b04776522edefd57e">const_volatile_mem_functor6</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#aed412f2606f91f9c11567c37ae6175bc">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#af8da04ac5f6e2252f963f4f4bb87c9fd">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#adff33012b1d7a20cb39c41c19b1db9a5">operator()</a>(const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#a5cf522fd8072a8f77e56cae87d65892f">operator()</a>(const T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#a9f866db08b59a0960875f7608a0c93f0">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">const_volatile_mem_functor6</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1const__volatile__mem__functor6-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html" title="const_volatile_mem_functor6 wraps const volatile methods with 6 argument(s).">const_volatile_mem_functor6</a> wraps const volatile methods with 6 argument(s).
+ <a href="classsigc_1_1const__volatile__mem__functor6.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1const__volatile__mem__functor6__inherit__graph.png" border="0" usemap="#asigc_1_1const__volatile__mem__functor6_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1const__volatile__mem__functor6_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_01_4_inherit__map" id="asigc_1_1const__volatile__mem__functor6_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_01_4_inherit__map">
+<area shape="rect" title="const_volatile_mem_functor6 wraps const volatile methods with 6 argument(s)." alt="" coords="193,5,391,91"/>
+<area shape="rect" href="classsigc_1_1bound__const__volatile__mem__functor6.html" title="bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object..." alt="" coords="439,13,668,83"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,35,145,61"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:af8da04ac5f6e2252f963f4f4bb87c9fd"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#af8da04ac5f6e2252f963f4f4bb87c9fd">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile</td></tr>
+<tr class="separator:af8da04ac5f6e2252f963f4f4bb87c9fd"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f866db08b59a0960875f7608a0c93f0"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#a9f866db08b59a0960875f7608a0c93f0">result_type</a></td></tr>
+<tr class="separator:a9f866db08b59a0960875f7608a0c93f0"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:aa921f2d1cea8ddd987cdaa8df6479fab"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#aa921f2d1cea8ddd987cdaa8df6479fab">const_volatile_mem_functor6</a> ()</td></tr>
+<tr class="memdesc:aa921f2d1cea8ddd987cdaa8df6479fab"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__volatile__mem__functor6.html#aa921f2d1cea8ddd987cdaa8df6479fab">More...</a><br /></td></tr>
+<tr class="separator:aa921f2d1cea8ddd987cdaa8df6479fab"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a09704c72e9b0353b04776522edefd57e"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#a09704c72e9b0353b04776522edefd57e">const_volatile_mem_functor6</a> (<a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#af8da04ac5f6e2252f963f4f4bb87c9fd">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a09704c72e9b0353b04776522edefd57e"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html" title="const_volatile_mem_functor6 wraps const volatile methods with 6 argument(s).">const_volatile_mem_functor6</a> object that wraps the passed method. <a href="classsigc_1_1const__volatile__mem__functor6.html#a09704c72e9b0353b04776522edefd57e">More...</a><br /></td></tr>
+<tr class="separator:a09704c72e9b0353b04776522edefd57e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5cf522fd8072a8f77e56cae87d65892f"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#a5cf522fd8072a8f77e56cae87d65892f">operator()</a> (const T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:a5cf522fd8072a8f77e56cae87d65892f"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor6.html#a5cf522fd8072a8f77e56cae87d65892f">More...</a><br /></td></tr>
+<tr class="separator:a5cf522fd8072a8f77e56cae87d65892f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adff33012b1d7a20cb39c41c19b1db9a5"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#adff33012b1d7a20cb39c41c19b1db9a5">operator()</a> (const T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:adff33012b1d7a20cb39c41c19b1db9a5"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor6.html#adff33012b1d7a20cb39c41c19b1db9a5">More...</a><br /></td></tr>
+<tr class="separator:adff33012b1d7a20cb39c41c19b1db9a5"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:aed412f2606f91f9c11567c37ae6175bc"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#af8da04ac5f6e2252f963f4f4bb87c9fd">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#aed412f2606f91f9c11567c37ae6175bc">func_ptr_</a></td></tr>
+<tr class="separator:aed412f2606f91f9c11567c37ae6175bc"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6><br />
+class sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></h3>
+
+<p><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html" title="const_volatile_mem_functor6 wraps const volatile methods with 6 argument(s).">const_volatile_mem_functor6</a> wraps const volatile methods with 6 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html" title="const_volatile_mem_functor6 wraps const volatile methods with 6 argument(s).">const_volatile_mem_functor6</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#adff33012b1d7a20cb39c41c19b1db9a5" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#adff33012b1d7a20cb39c41c19b1db9a5" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#adff33012b1d7a20cb39c41c19b1db9a5" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#adff33012b1d7a20cb39c41c19b1db9a5" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#adff33012b1d7a20cb39c41c19b1db9a5" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg6</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#adff33012b1d7a20cb39c41c19b1db9a5" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#adff33012b1d7a20cb39c41c19b1db9a5" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="af8da04ac5f6e2252f963f4f4bb87c9fd"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af8da04ac5f6e2252f963f4f4bb87c9fd">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">sigc::const_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::function_type) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a9f866db08b59a0960875f7608a0c93f0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9f866db08b59a0960875f7608a0c93f0">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">sigc::const_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#a9f866db08b59a0960875f7608a0c93f0">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="aa921f2d1cea8ddd987cdaa8df6479fab"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa921f2d1cea8ddd987cdaa8df6479fab">◆ </a></span>const_volatile_mem_functor6() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">sigc::const_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">const_volatile_mem_functor6</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="a09704c72e9b0353b04776522edefd57e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a09704c72e9b0353b04776522edefd57e">◆ </a></span>const_volatile_mem_functor6() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">sigc::const_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">const_volatile_mem_functor6</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#af8da04ac5f6e2252f963f4f4bb87c9fd">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html" title="const_volatile_mem_functor6 wraps const volatile methods with 6 argument(s).">const_volatile_mem_functor6</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#adff33012b1d7a20cb39c41c19b1db9a5" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a5cf522fd8072a8f77e56cae87d65892f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5cf522fd8072a8f77e56cae87d65892f">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">sigc::const_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="adff33012b1d7a20cb39c41c19b1db9a5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#adff33012b1d7a20cb39c41c19b1db9a5">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">sigc::const_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000160">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="aed412f2606f91f9c11567c37ae6175bc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aed412f2606f91f9c11567c37ae6175bc">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#af8da04ac5f6e2252f963f4f4bb87c9fd">function_type</a> <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">sigc::const_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >" name="sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >">
+<area shape="rect" id="node1" title="const_volatile_mem_functor6 wraps const volatile methods with 6 argument(s)." alt="" coords="193,5,391,91"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__const__volatile__mem__functor6.html" title="bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object..." alt="" coords="439,13,668,83"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,35,145,61"/>
+</map>
--- /dev/null
+35e408522f3dd230843c9bbff24ec305
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">const_volatile_mem_functor7</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#ac71290a7277b022f8a8d7abc4158a7ae">const_volatile_mem_functor7</a>()</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a95dcac66fbdb4c3b92682a1ddaa0309c">const_volatile_mem_functor7</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a3f19b8bff74776f040492d3410c54fa1">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a7e3bac9b817c848b96e9d1b257be1de5">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a1c9477eed5eef826a4666817aee9ea25">operator()</a>(const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a9cb200c4d7a95edf269ede2b9c7ab060">operator()</a>(const T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a25cb7e6ed71406c5b91ab2696ad8e623">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">const_volatile_mem_functor7</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1const__volatile__mem__functor7-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html" title="const_volatile_mem_functor7 wraps const volatile methods with 7 argument(s).">const_volatile_mem_functor7</a> wraps const volatile methods with 7 argument(s).
+ <a href="classsigc_1_1const__volatile__mem__functor7.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1const__volatile__mem__functor7__inherit__graph.png" border="0" usemap="#asigc_1_1const__volatile__mem__functor7_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1const__volatile__mem__functor7_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map" id="asigc_1_1const__volatile__mem__functor7_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map">
+<area shape="rect" title="const_volatile_mem_functor7 wraps const volatile methods with 7 argument(s)." alt="" coords="193,5,391,91"/>
+<area shape="rect" href="classsigc_1_1bound__const__volatile__mem__functor7.html" title="bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object..." alt="" coords="439,5,657,91"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,35,145,61"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a7e3bac9b817c848b96e9d1b257be1de5"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a7e3bac9b817c848b96e9d1b257be1de5">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile</td></tr>
+<tr class="separator:a7e3bac9b817c848b96e9d1b257be1de5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a25cb7e6ed71406c5b91ab2696ad8e623"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a25cb7e6ed71406c5b91ab2696ad8e623">result_type</a></td></tr>
+<tr class="separator:a25cb7e6ed71406c5b91ab2696ad8e623"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:ac71290a7277b022f8a8d7abc4158a7ae"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#ac71290a7277b022f8a8d7abc4158a7ae">const_volatile_mem_functor7</a> ()</td></tr>
+<tr class="memdesc:ac71290a7277b022f8a8d7abc4158a7ae"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1const__volatile__mem__functor7.html#ac71290a7277b022f8a8d7abc4158a7ae">More...</a><br /></td></tr>
+<tr class="separator:ac71290a7277b022f8a8d7abc4158a7ae"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a95dcac66fbdb4c3b92682a1ddaa0309c"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a95dcac66fbdb4c3b92682a1ddaa0309c">const_volatile_mem_functor7</a> (<a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a7e3bac9b817c848b96e9d1b257be1de5">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a95dcac66fbdb4c3b92682a1ddaa0309c"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html" title="const_volatile_mem_functor7 wraps const volatile methods with 7 argument(s).">const_volatile_mem_functor7</a> object that wraps the passed method. <a href="classsigc_1_1const__volatile__mem__functor7.html#a95dcac66fbdb4c3b92682a1ddaa0309c">More...</a><br /></td></tr>
+<tr class="separator:a95dcac66fbdb4c3b92682a1ddaa0309c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9cb200c4d7a95edf269ede2b9c7ab060"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a9cb200c4d7a95edf269ede2b9c7ab060">operator()</a> (const T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:a9cb200c4d7a95edf269ede2b9c7ab060"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor7.html#a9cb200c4d7a95edf269ede2b9c7ab060">More...</a><br /></td></tr>
+<tr class="separator:a9cb200c4d7a95edf269ede2b9c7ab060"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1c9477eed5eef826a4666817aee9ea25"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a1c9477eed5eef826a4666817aee9ea25">operator()</a> (const T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:a1c9477eed5eef826a4666817aee9ea25"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1const__volatile__mem__functor7.html#a1c9477eed5eef826a4666817aee9ea25">More...</a><br /></td></tr>
+<tr class="separator:a1c9477eed5eef826a4666817aee9ea25"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:a3f19b8bff74776f040492d3410c54fa1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a7e3bac9b817c848b96e9d1b257be1de5">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a3f19b8bff74776f040492d3410c54fa1">func_ptr_</a></td></tr>
+<tr class="separator:a3f19b8bff74776f040492d3410c54fa1"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7><br />
+class sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></h3>
+
+<p><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html" title="const_volatile_mem_functor7 wraps const volatile methods with 7 argument(s).">const_volatile_mem_functor7</a> wraps const volatile methods with 7 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html" title="const_volatile_mem_functor7 wraps const volatile methods with 7 argument(s).">const_volatile_mem_functor7</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a1c9477eed5eef826a4666817aee9ea25" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a1c9477eed5eef826a4666817aee9ea25" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a1c9477eed5eef826a4666817aee9ea25" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a1c9477eed5eef826a4666817aee9ea25" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a1c9477eed5eef826a4666817aee9ea25" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg6</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a1c9477eed5eef826a4666817aee9ea25" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg7</em> Argument type used in the definition of <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a1c9477eed5eef826a4666817aee9ea25" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a1c9477eed5eef826a4666817aee9ea25" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a7e3bac9b817c848b96e9d1b257be1de5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7e3bac9b817c848b96e9d1b257be1de5">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">sigc::const_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::function_type) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a25cb7e6ed71406c5b91ab2696ad8e623"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a25cb7e6ed71406c5b91ab2696ad8e623">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">sigc::const_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a25cb7e6ed71406c5b91ab2696ad8e623">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="ac71290a7277b022f8a8d7abc4158a7ae"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac71290a7277b022f8a8d7abc4158a7ae">◆ </a></span>const_volatile_mem_functor7() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">sigc::const_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">const_volatile_mem_functor7</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="a95dcac66fbdb4c3b92682a1ddaa0309c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a95dcac66fbdb4c3b92682a1ddaa0309c">◆ </a></span>const_volatile_mem_functor7() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">sigc::const_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">const_volatile_mem_functor7</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a7e3bac9b817c848b96e9d1b257be1de5">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html" title="const_volatile_mem_functor7 wraps const volatile methods with 7 argument(s).">const_volatile_mem_functor7</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a1c9477eed5eef826a4666817aee9ea25" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a9cb200c4d7a95edf269ede2b9c7ab060"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9cb200c4d7a95edf269ede2b9c7ab060">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">sigc::const_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > </td>
+ <td class="paramname"><em>_A_a7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a7</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a1c9477eed5eef826a4666817aee9ea25"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1c9477eed5eef826a4666817aee9ea25">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">sigc::const_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">const T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > </td>
+ <td class="paramname"><em>_A_a7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000161">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a7</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a3f19b8bff74776f040492d3410c54fa1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3f19b8bff74776f040492d3410c54fa1">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a7e3bac9b817c848b96e9d1b257be1de5">function_type</a> <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">sigc::const_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >" name="sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >">
+<area shape="rect" id="node1" title="const_volatile_mem_functor7 wraps const volatile methods with 7 argument(s)." alt="" coords="193,5,391,91"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__const__volatile__mem__functor7.html" title="bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object..." alt="" coords="439,5,657,91"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,35,145,61"/>
+</map>
--- /dev/null
+b4ebce09ad2e0eca132b9bcaaff16de8
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1limit__reference.html">limit_reference</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::limit_reference< T_type, I_derives_trackable > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1limit__reference.html">sigc::limit_reference< T_type, I_derives_trackable ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1limit__reference.html#affd2902cd78ccdae45c499058c83e992">invoke</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1limit__reference.html">sigc::limit_reference< T_type, I_derives_trackable ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1limit__reference.html#a58bf17e1eaa63d86336c831fa885bc66">limit_reference</a>(T_type & _A_target)</td><td class="entry"><a class="el" href="classsigc_1_1limit__reference.html">sigc::limit_reference< T_type, I_derives_trackable ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1limit__reference.html#affeb3929fdc606c8fb7f8f29fa6fd12d">visit</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1limit__reference.html">sigc::limit_reference< T_type, I_derives_trackable ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::limit_reference< T_type, I_derives_trackable > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1limit__reference.html">limit_reference</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1limit__reference-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::limit_reference< T_type, I_derives_trackable > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>A limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>, then <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each<>()</a> will "limit" itself to the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference instead of the derived reference.
+ <a href="classsigc_1_1limit__reference.html#details">More...</a></p>
+
+<p><code>#include <sigc++/limit_reference.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a58bf17e1eaa63d86336c831fa885bc66"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1limit__reference.html#a58bf17e1eaa63d86336c831fa885bc66">limit_reference</a> (T_type & _A_target)</td></tr>
+<tr class="memdesc:a58bf17e1eaa63d86336c831fa885bc66"><td class="mdescLeft"> </td><td class="mdescRight">Constructor. <a href="classsigc_1_1limit__reference.html#a58bf17e1eaa63d86336c831fa885bc66">More...</a><br /></td></tr>
+<tr class="separator:a58bf17e1eaa63d86336c831fa885bc66"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:affd2902cd78ccdae45c499058c83e992"><td class="memItemLeft" align="right" valign="top">T_type & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1limit__reference.html#affd2902cd78ccdae45c499058c83e992">invoke</a> () const</td></tr>
+<tr class="memdesc:affd2902cd78ccdae45c499058c83e992"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the reference. <a href="classsigc_1_1limit__reference.html#affd2902cd78ccdae45c499058c83e992">More...</a><br /></td></tr>
+<tr class="separator:affd2902cd78ccdae45c499058c83e992"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:affeb3929fdc606c8fb7f8f29fa6fd12d"><td class="memItemLeft" align="right" valign="top">const T_type & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1limit__reference.html#affeb3929fdc606c8fb7f8f29fa6fd12d">visit</a> () const</td></tr>
+<tr class="memdesc:affeb3929fdc606c8fb7f8f29fa6fd12d"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the entity to visit for <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each()</a>. <a href="classsigc_1_1limit__reference.html#affeb3929fdc606c8fb7f8f29fa6fd12d">More...</a><br /></td></tr>
+<tr class="separator:affeb3929fdc606c8fb7f8f29fa6fd12d"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_type, bool I_derives_trackable = std::is_base_of<trackable, T_type>::value><br />
+class sigc::limit_reference< T_type, I_derives_trackable ></h3>
+
+<p>A limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>, then <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each<>()</a> will "limit" itself to the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference instead of the derived reference. </p>
+<p>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.</p>
+<p>If Foo inherits from trackable then both the derived reference and the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference are stored, so we can later retrieve the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference without doing an implicit conversion. To retrieve the derived reference (so that you invoke methods or members of it), use <a class="el" href="classsigc_1_1limit__reference.html#affd2902cd78ccdae45c499058c83e992" title="Retrieve the reference.">invoke()</a>. To retrieve the trackable reference (so that you can call <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each()</a> on it), you use <a class="el" href="classsigc_1_1limit__reference.html#affeb3929fdc606c8fb7f8f29fa6fd12d" title="Retrieve the entity to visit for visit_each().">visit()</a>.</p>
+<p>If Foo does not inherit from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> then <a class="el" href="classsigc_1_1limit__reference.html#affd2902cd78ccdae45c499058c83e992" title="Retrieve the reference.">invoke()</a> and <a class="el" href="classsigc_1_1limit__reference.html#affeb3929fdc606c8fb7f8f29fa6fd12d" title="Retrieve the entity to visit for visit_each().">visit()</a> just return the derived reference.</p>
+<p>This is used for bound (<a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">sigc::bind</a>) slot parameters (via <a class="el" href="classsigc_1_1bound__argument.html" title="A bound_argument<Foo> object stores a bound (for instance, with sigc::bind(), or sigc::bind_return())...">bound_argument</a>), bound return values, and, with <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a>, the reference to the handling object.</p>
+<ul>
+<li><em>T_type</em> The type of the reference. </li>
+</ul>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a58bf17e1eaa63d86336c831fa885bc66"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a58bf17e1eaa63d86336c831fa885bc66">◆ </a></span>limit_reference()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type , bool I_derives_trackable = std::is_base_of<trackable, T_type>::value> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1limit__reference.html">sigc::limit_reference</a>< T_type, I_derives_trackable >::<a class="el" href="classsigc_1_1limit__reference.html">limit_reference</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_type & </td>
+ <td class="paramname"><em>_A_target</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_target</td><td>The reference to limit. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="affd2902cd78ccdae45c499058c83e992"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#affd2902cd78ccdae45c499058c83e992">◆ </a></span>invoke()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type , bool I_derives_trackable = std::is_base_of<trackable, T_type>::value> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_type& <a class="el" href="classsigc_1_1limit__reference.html">sigc::limit_reference</a>< T_type, I_derives_trackable >::invoke </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Retrieve the reference. </p>
+<p>This is always a reference to the derived instance. </p><dl class="section return"><dt>Returns</dt><dd>The reference. </dd></dl>
+
+</div>
+</div>
+<a id="affeb3929fdc606c8fb7f8f29fa6fd12d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#affeb3929fdc606c8fb7f8f29fa6fd12d">◆ </a></span>visit()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type , bool I_derives_trackable = std::is_base_of<trackable, T_type>::value> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">const T_type& <a class="el" href="classsigc_1_1limit__reference.html">sigc::limit_reference</a>< T_type, I_derives_trackable >::visit </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Retrieve the entity to visit for <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each()</a>. </p>
+<p>Depending on the template specialization, this is either a derived reference, or <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>& if T_type derives from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>. </p><dl class="section return"><dt>Returns</dt><dd>The reference. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html">limit_reference< T_type, true ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::limit_reference< T_type, true > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html">sigc::limit_reference< T_type, true ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html#a6c8067da8b8c15361127ad25efab6903">invoke</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html">sigc::limit_reference< T_type, true ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html#a26ef98ef1f11a4b5891d426e9722c2c8">limit_reference</a>(T_type & _A_target)</td><td class="entry"><a class="el" href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html">sigc::limit_reference< T_type, true ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html#a85e56a8140929d71b2bdbd091e348c3a">visit</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html">sigc::limit_reference< T_type, true ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::limit_reference< T_type, true > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html">limit_reference< T_type, true ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::limit_reference< T_type, true > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1limit__reference.html" title="A limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from sig...">limit_reference</a> object for a class that derives from trackable.
+ <a href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/limit_reference.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a26ef98ef1f11a4b5891d426e9722c2c8"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html#a26ef98ef1f11a4b5891d426e9722c2c8">limit_reference</a> (T_type & _A_target)</td></tr>
+<tr class="memdesc:a26ef98ef1f11a4b5891d426e9722c2c8"><td class="mdescLeft"> </td><td class="mdescRight">Constructor. <a href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html#a26ef98ef1f11a4b5891d426e9722c2c8">More...</a><br /></td></tr>
+<tr class="separator:a26ef98ef1f11a4b5891d426e9722c2c8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a6c8067da8b8c15361127ad25efab6903"><td class="memItemLeft" align="right" valign="top">T_type & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html#a6c8067da8b8c15361127ad25efab6903">invoke</a> () const</td></tr>
+<tr class="memdesc:a6c8067da8b8c15361127ad25efab6903"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the reference. <a href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html#a6c8067da8b8c15361127ad25efab6903">More...</a><br /></td></tr>
+<tr class="separator:a6c8067da8b8c15361127ad25efab6903"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a85e56a8140929d71b2bdbd091e348c3a"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html#a85e56a8140929d71b2bdbd091e348c3a">visit</a> () const</td></tr>
+<tr class="memdesc:a85e56a8140929d71b2bdbd091e348c3a"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the entity to visit for <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each()</a>. <a href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html#a85e56a8140929d71b2bdbd091e348c3a">More...</a><br /></td></tr>
+<tr class="separator:a85e56a8140929d71b2bdbd091e348c3a"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_type><br />
+class sigc::limit_reference< T_type, true ></h3>
+
+<p><a class="el" href="classsigc_1_1limit__reference.html" title="A limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from sig...">limit_reference</a> object for a class that derives from trackable. </p>
+<ul>
+<li><em>T_type</em> The type of the reference. </li>
+</ul>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a26ef98ef1f11a4b5891d426e9722c2c8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a26ef98ef1f11a4b5891d426e9722c2c8">◆ </a></span>limit_reference()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1limit__reference.html">sigc::limit_reference</a>< T_type, true >::<a class="el" href="classsigc_1_1limit__reference.html">limit_reference</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_type & </td>
+ <td class="paramname"><em>_A_target</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_target</td><td>The reference to limit. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a6c8067da8b8c15361127ad25efab6903"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a6c8067da8b8c15361127ad25efab6903">◆ </a></span>invoke()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_type& <a class="el" href="classsigc_1_1limit__reference.html">sigc::limit_reference</a>< T_type, true >::invoke </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Retrieve the reference. </p>
+<p>This is always a reference to the derived instance. </p><dl class="section return"><dt>Returns</dt><dd>The reference. </dd></dl>
+
+</div>
+</div>
+<a id="a85e56a8140929d71b2bdbd091e348c3a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a85e56a8140929d71b2bdbd091e348c3a">◆ </a></span>visit()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">const <a class="el" href="structsigc_1_1trackable.html">trackable</a>& <a class="el" href="classsigc_1_1limit__reference.html">sigc::limit_reference</a>< T_type, true >::visit </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Retrieve the entity to visit for <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each()</a>. </p>
+<p>Depending on the template specialization, this is either a derived reference, or <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>& if T_type derives from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>. </p><dl class="section return"><dt>Returns</dt><dd>The reference. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1mem__functor0.html">mem_functor0</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::mem_functor0< T_return, T_obj > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1mem__functor0.html">sigc::mem_functor0< T_return, T_obj ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor0.html#a1f7b51d412900f55e155ecdd848fa283">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1mem__functor0.html">sigc::mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor0.html#a2b54ee0f1d0b0ca4f25707c85a5d4bab">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor0.html">sigc::mem_functor0< T_return, T_obj ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor0.html#ad598cd301fc54f3aa4da2b9e3c16bc81">mem_functor0</a>()</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor0.html">sigc::mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor0.html#a5655f48c6f36716dc15daf584f20d51c">mem_functor0</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor0.html">sigc::mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor0.html#a0a8b70a8f59ddbdc3f1a9892c634bf48">operator()</a>(T_obj * _A_obj) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor0.html">sigc::mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor0.html#a51d5213c9d41b51e3b8cca705bd801cc">operator()</a>(T_obj & _A_obj) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor0.html">sigc::mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor0.html#aa679f73c7b786540686c110628a71dde">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor0.html">sigc::mem_functor0< T_return, T_obj ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::mem_functor0< T_return, T_obj > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1mem__functor0.html">mem_functor0</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1mem__functor0-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::mem_functor0< T_return, T_obj > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1mem__functor0.html" title="mem_functor0 wraps methods with 0 argument(s).">mem_functor0</a> wraps methods with 0 argument(s).
+ <a href="classsigc_1_1mem__functor0.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::mem_functor0< T_return, T_obj >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1mem__functor0__inherit__graph.png" border="0" usemap="#asigc_1_1mem__functor0_3_01T__return_00_01T__obj_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1mem__functor0_3_01T__return_00_01T__obj_01_4_inherit__map" id="asigc_1_1mem__functor0_3_01T__return_00_01T__obj_01_4_inherit__map">
+<area shape="rect" title="mem_functor0 wraps methods with 0 argument(s)." alt="" coords="29,80,180,121"/>
+<area shape="rect" href="classsigc_1_1bound__mem__functor0.html" title="bound_mem_functor0 encapsulates a method with 0 arguments and an object instance." alt="" coords="5,169,204,211"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="35,5,175,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a2b54ee0f1d0b0ca4f25707c85a5d4bab"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor0.html#a2b54ee0f1d0b0ca4f25707c85a5d4bab">function_type</a>) ()</td></tr>
+<tr class="separator:a2b54ee0f1d0b0ca4f25707c85a5d4bab"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa679f73c7b786540686c110628a71dde"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor0.html#aa679f73c7b786540686c110628a71dde">result_type</a></td></tr>
+<tr class="separator:aa679f73c7b786540686c110628a71dde"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:ad598cd301fc54f3aa4da2b9e3c16bc81"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor0.html#ad598cd301fc54f3aa4da2b9e3c16bc81">mem_functor0</a> ()</td></tr>
+<tr class="memdesc:ad598cd301fc54f3aa4da2b9e3c16bc81"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1mem__functor0.html#ad598cd301fc54f3aa4da2b9e3c16bc81">More...</a><br /></td></tr>
+<tr class="separator:ad598cd301fc54f3aa4da2b9e3c16bc81"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5655f48c6f36716dc15daf584f20d51c"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor0.html#a5655f48c6f36716dc15daf584f20d51c">mem_functor0</a> (<a class="el" href="classsigc_1_1mem__functor0.html#a2b54ee0f1d0b0ca4f25707c85a5d4bab">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a5655f48c6f36716dc15daf584f20d51c"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1mem__functor0.html" title="mem_functor0 wraps methods with 0 argument(s).">mem_functor0</a> object that wraps the passed method. <a href="classsigc_1_1mem__functor0.html#a5655f48c6f36716dc15daf584f20d51c">More...</a><br /></td></tr>
+<tr class="separator:a5655f48c6f36716dc15daf584f20d51c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a51d5213c9d41b51e3b8cca705bd801cc"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor0.html#a51d5213c9d41b51e3b8cca705bd801cc">operator()</a> (T_obj & _A_obj) const</td></tr>
+<tr class="memdesc:a51d5213c9d41b51e3b8cca705bd801cc"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor0.html#a51d5213c9d41b51e3b8cca705bd801cc">More...</a><br /></td></tr>
+<tr class="separator:a51d5213c9d41b51e3b8cca705bd801cc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0a8b70a8f59ddbdc3f1a9892c634bf48"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor0.html#a0a8b70a8f59ddbdc3f1a9892c634bf48">operator()</a> (T_obj * _A_obj) const</td></tr>
+<tr class="memdesc:a0a8b70a8f59ddbdc3f1a9892c634bf48"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor0.html#a0a8b70a8f59ddbdc3f1a9892c634bf48">More...</a><br /></td></tr>
+<tr class="separator:a0a8b70a8f59ddbdc3f1a9892c634bf48"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:a1f7b51d412900f55e155ecdd848fa283"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor0.html#a2b54ee0f1d0b0ca4f25707c85a5d4bab">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor0.html#a1f7b51d412900f55e155ecdd848fa283">func_ptr_</a></td></tr>
+<tr class="separator:a1f7b51d412900f55e155ecdd848fa283"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj><br />
+class sigc::mem_functor0< T_return, T_obj ></h3>
+
+<p><a class="el" href="classsigc_1_1mem__functor0.html" title="mem_functor0 wraps methods with 0 argument(s).">mem_functor0</a> wraps methods with 0 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1mem__functor0.html" title="mem_functor0 wraps methods with 0 argument(s).">mem_functor0</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1mem__functor0.html#a0a8b70a8f59ddbdc3f1a9892c634bf48" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a2b54ee0f1d0b0ca4f25707c85a5d4bab"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2b54ee0f1d0b0ca4f25707c85a5d4bab">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1mem__functor0.html">sigc::mem_functor0</a>< T_return, T_obj >::function_type) ()</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aa679f73c7b786540686c110628a71dde"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa679f73c7b786540686c110628a71dde">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1mem__functor0.html">sigc::mem_functor0</a>< T_return, T_obj >::<a class="el" href="classsigc_1_1mem__functor0.html#aa679f73c7b786540686c110628a71dde">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="ad598cd301fc54f3aa4da2b9e3c16bc81"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad598cd301fc54f3aa4da2b9e3c16bc81">◆ </a></span>mem_functor0() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor0.html">sigc::mem_functor0</a>< T_return, T_obj >::<a class="el" href="classsigc_1_1mem__functor0.html">mem_functor0</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="a5655f48c6f36716dc15daf584f20d51c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5655f48c6f36716dc15daf584f20d51c">◆ </a></span>mem_functor0() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor0.html">sigc::mem_functor0</a>< T_return, T_obj >::<a class="el" href="classsigc_1_1mem__functor0.html">mem_functor0</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1mem__functor0.html#a2b54ee0f1d0b0ca4f25707c85a5d4bab">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1mem__functor0.html" title="mem_functor0 wraps methods with 0 argument(s).">mem_functor0</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1mem__functor0.html#a0a8b70a8f59ddbdc3f1a9892c634bf48" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a51d5213c9d41b51e3b8cca705bd801cc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a51d5213c9d41b51e3b8cca705bd801cc">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1mem__functor0.html">sigc::mem_functor0</a>< T_return, T_obj >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a0a8b70a8f59ddbdc3f1a9892c634bf48"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0a8b70a8f59ddbdc3f1a9892c634bf48">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1mem__functor0.html">sigc::mem_functor0</a>< T_return, T_obj >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000130">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a1f7b51d412900f55e155ecdd848fa283"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1f7b51d412900f55e155ecdd848fa283">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor0.html#a2b54ee0f1d0b0ca4f25707c85a5d4bab">function_type</a> <a class="el" href="classsigc_1_1mem__functor0.html">sigc::mem_functor0</a>< T_return, T_obj >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::mem_functor0< T_return, T_obj >" name="sigc::mem_functor0< T_return, T_obj >">
+<area shape="rect" id="node1" title="mem_functor0 wraps methods with 0 argument(s)." alt="" coords="29,80,180,121"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__mem__functor0.html" title="bound_mem_functor0 encapsulates a method with 0 arguments and an object instance." alt="" coords="5,169,204,211"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="35,5,175,32"/>
+</map>
--- /dev/null
+6bc0fe77267cc7c9b9ca68cbe28f0650
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1mem__functor1.html">mem_functor1</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::mem_functor1< T_return, T_obj, T_arg1 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1mem__functor1.html">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor1.html#af5981be86ea36d59e86234ef5cd2b5a4">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1mem__functor1.html">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor1.html#a4f10314fc4d7811e126aa0d8dc9fea8c">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor1.html">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor1.html#ab97c2206275025d8d1e7665c12322eba">mem_functor1</a>()</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor1.html">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor1.html#a63230b348e410f7d2f245df1f2af019a">mem_functor1</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor1.html">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor1.html#a11fa461ba0bbddc9e5a7dd687e90591b">operator()</a>(T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor1.html">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor1.html#a55a370a320def89e80aa37141c101c98">operator()</a>(T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor1.html">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor1.html#a7c7ab28530e2f678eae87772253df709">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor1.html">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::mem_functor1< T_return, T_obj, T_arg1 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1mem__functor1.html">mem_functor1</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1mem__functor1-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::mem_functor1< T_return, T_obj, T_arg1 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1mem__functor1.html" title="mem_functor1 wraps methods with 1 argument(s).">mem_functor1</a> wraps methods with 1 argument(s).
+ <a href="classsigc_1_1mem__functor1.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::mem_functor1< T_return, T_obj, T_arg1 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1mem__functor1__inherit__graph.png" border="0" usemap="#asigc_1_1mem__functor1_3_01T__return_00_01T__obj_00_01T__arg1_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1mem__functor1_3_01T__return_00_01T__obj_00_01T__arg1_01_4_inherit__map" id="asigc_1_1mem__functor1_3_01T__return_00_01T__obj_00_01T__arg1_01_4_inherit__map">
+<area shape="rect" title="mem_functor1 wraps methods with 1 argument(s)." alt="" coords="31,80,181,136"/>
+<area shape="rect" href="classsigc_1_1bound__mem__functor1.html" title="bound_mem_functor1 encapsulates a method with 1 arguments and an object instance." alt="" coords="5,184,207,225"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="36,5,176,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a4f10314fc4d7811e126aa0d8dc9fea8c"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor1.html#a4f10314fc4d7811e126aa0d8dc9fea8c">function_type</a>) (T_arg1)</td></tr>
+<tr class="separator:a4f10314fc4d7811e126aa0d8dc9fea8c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7c7ab28530e2f678eae87772253df709"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor1.html#a7c7ab28530e2f678eae87772253df709">result_type</a></td></tr>
+<tr class="separator:a7c7ab28530e2f678eae87772253df709"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:ab97c2206275025d8d1e7665c12322eba"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor1.html#ab97c2206275025d8d1e7665c12322eba">mem_functor1</a> ()</td></tr>
+<tr class="memdesc:ab97c2206275025d8d1e7665c12322eba"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1mem__functor1.html#ab97c2206275025d8d1e7665c12322eba">More...</a><br /></td></tr>
+<tr class="separator:ab97c2206275025d8d1e7665c12322eba"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a63230b348e410f7d2f245df1f2af019a"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor1.html#a63230b348e410f7d2f245df1f2af019a">mem_functor1</a> (<a class="el" href="classsigc_1_1mem__functor1.html#a4f10314fc4d7811e126aa0d8dc9fea8c">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a63230b348e410f7d2f245df1f2af019a"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1mem__functor1.html" title="mem_functor1 wraps methods with 1 argument(s).">mem_functor1</a> object that wraps the passed method. <a href="classsigc_1_1mem__functor1.html#a63230b348e410f7d2f245df1f2af019a">More...</a><br /></td></tr>
+<tr class="separator:a63230b348e410f7d2f245df1f2af019a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a55a370a320def89e80aa37141c101c98"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor1.html#a55a370a320def89e80aa37141c101c98">operator()</a> (T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a55a370a320def89e80aa37141c101c98"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor1.html#a55a370a320def89e80aa37141c101c98">More...</a><br /></td></tr>
+<tr class="separator:a55a370a320def89e80aa37141c101c98"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a11fa461ba0bbddc9e5a7dd687e90591b"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor1.html#a11fa461ba0bbddc9e5a7dd687e90591b">operator()</a> (T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a11fa461ba0bbddc9e5a7dd687e90591b"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor1.html#a11fa461ba0bbddc9e5a7dd687e90591b">More...</a><br /></td></tr>
+<tr class="separator:a11fa461ba0bbddc9e5a7dd687e90591b"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:af5981be86ea36d59e86234ef5cd2b5a4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor1.html#a4f10314fc4d7811e126aa0d8dc9fea8c">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor1.html#af5981be86ea36d59e86234ef5cd2b5a4">func_ptr_</a></td></tr>
+<tr class="separator:af5981be86ea36d59e86234ef5cd2b5a4"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1><br />
+class sigc::mem_functor1< T_return, T_obj, T_arg1 ></h3>
+
+<p><a class="el" href="classsigc_1_1mem__functor1.html" title="mem_functor1 wraps methods with 1 argument(s).">mem_functor1</a> wraps methods with 1 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1mem__functor1.html" title="mem_functor1 wraps methods with 1 argument(s).">mem_functor1</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1mem__functor1.html#a11fa461ba0bbddc9e5a7dd687e90591b" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1mem__functor1.html#a11fa461ba0bbddc9e5a7dd687e90591b" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a4f10314fc4d7811e126aa0d8dc9fea8c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4f10314fc4d7811e126aa0d8dc9fea8c">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1mem__functor1.html">sigc::mem_functor1</a>< T_return, T_obj, T_arg1 >::function_type) (T_arg1)</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a7c7ab28530e2f678eae87772253df709"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7c7ab28530e2f678eae87772253df709">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1mem__functor1.html">sigc::mem_functor1</a>< T_return, T_obj, T_arg1 >::<a class="el" href="classsigc_1_1mem__functor1.html#a7c7ab28530e2f678eae87772253df709">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="ab97c2206275025d8d1e7665c12322eba"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab97c2206275025d8d1e7665c12322eba">◆ </a></span>mem_functor1() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor1.html">sigc::mem_functor1</a>< T_return, T_obj, T_arg1 >::<a class="el" href="classsigc_1_1mem__functor1.html">mem_functor1</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="a63230b348e410f7d2f245df1f2af019a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a63230b348e410f7d2f245df1f2af019a">◆ </a></span>mem_functor1() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor1.html">sigc::mem_functor1</a>< T_return, T_obj, T_arg1 >::<a class="el" href="classsigc_1_1mem__functor1.html">mem_functor1</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1mem__functor1.html#a4f10314fc4d7811e126aa0d8dc9fea8c">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1mem__functor1.html" title="mem_functor1 wraps methods with 1 argument(s).">mem_functor1</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1mem__functor1.html#a11fa461ba0bbddc9e5a7dd687e90591b" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a55a370a320def89e80aa37141c101c98"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a55a370a320def89e80aa37141c101c98">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1mem__functor1.html">sigc::mem_functor1</a>< T_return, T_obj, T_arg1 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a11fa461ba0bbddc9e5a7dd687e90591b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a11fa461ba0bbddc9e5a7dd687e90591b">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1mem__functor1.html">sigc::mem_functor1</a>< T_return, T_obj, T_arg1 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000131">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="af5981be86ea36d59e86234ef5cd2b5a4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af5981be86ea36d59e86234ef5cd2b5a4">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor1.html#a4f10314fc4d7811e126aa0d8dc9fea8c">function_type</a> <a class="el" href="classsigc_1_1mem__functor1.html">sigc::mem_functor1</a>< T_return, T_obj, T_arg1 >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::mem_functor1< T_return, T_obj, T_arg1 >" name="sigc::mem_functor1< T_return, T_obj, T_arg1 >">
+<area shape="rect" id="node1" title="mem_functor1 wraps methods with 1 argument(s)." alt="" coords="31,80,181,136"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__mem__functor1.html" title="bound_mem_functor1 encapsulates a method with 1 arguments and an object instance." alt="" coords="5,184,207,225"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="36,5,176,32"/>
+</map>
--- /dev/null
+f9ca59e2f82a8b5a33ef139451fb32f9
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1mem__functor2.html">mem_functor2</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1mem__functor2.html">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor2.html#aa4b00e1d6bb65c1c1791d314b5dcb4d6">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1mem__functor2.html">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor2.html#aa584cfe15bb8dc5b2931d2bfd034c118">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor2.html">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor2.html#a691e21d47b7a54b67605812f7e089299">mem_functor2</a>()</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor2.html">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor2.html#aeee1c7f263f8d7e7b6fa9be0156878fe">mem_functor2</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor2.html">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor2.html#ad5d0f74803537d1ed8b9678ac2da57d5">operator()</a>(T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor2.html">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor2.html#a6fe02ecb626919c1149888b03fde552e">operator()</a>(T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor2.html">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor2.html#a9080e942d35d226ea6f9dda097342f07">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor2.html">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1mem__functor2.html">mem_functor2</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1mem__functor2-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1mem__functor2.html" title="mem_functor2 wraps methods with 2 argument(s).">mem_functor2</a> wraps methods with 2 argument(s).
+ <a href="classsigc_1_1mem__functor2.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1mem__functor2__inherit__graph.png" border="0" usemap="#asigc_1_1mem__functor2_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1mem__functor2_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_01_4_inherit__map" id="asigc_1_1mem__functor2_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_01_4_inherit__map">
+<area shape="rect" title="mem_functor2 wraps methods with 2 argument(s)." alt="" coords="29,80,180,136"/>
+<area shape="rect" href="classsigc_1_1bound__mem__functor2.html" title="bound_mem_functor2 encapsulates a method with 2 arguments and an object instance." alt="" coords="5,184,204,240"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="35,5,175,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:aa584cfe15bb8dc5b2931d2bfd034c118"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor2.html#aa584cfe15bb8dc5b2931d2bfd034c118">function_type</a>) (T_arg1, T_arg2)</td></tr>
+<tr class="separator:aa584cfe15bb8dc5b2931d2bfd034c118"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9080e942d35d226ea6f9dda097342f07"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor2.html#a9080e942d35d226ea6f9dda097342f07">result_type</a></td></tr>
+<tr class="separator:a9080e942d35d226ea6f9dda097342f07"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a691e21d47b7a54b67605812f7e089299"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor2.html#a691e21d47b7a54b67605812f7e089299">mem_functor2</a> ()</td></tr>
+<tr class="memdesc:a691e21d47b7a54b67605812f7e089299"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1mem__functor2.html#a691e21d47b7a54b67605812f7e089299">More...</a><br /></td></tr>
+<tr class="separator:a691e21d47b7a54b67605812f7e089299"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aeee1c7f263f8d7e7b6fa9be0156878fe"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor2.html#aeee1c7f263f8d7e7b6fa9be0156878fe">mem_functor2</a> (<a class="el" href="classsigc_1_1mem__functor2.html#aa584cfe15bb8dc5b2931d2bfd034c118">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:aeee1c7f263f8d7e7b6fa9be0156878fe"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1mem__functor2.html" title="mem_functor2 wraps methods with 2 argument(s).">mem_functor2</a> object that wraps the passed method. <a href="classsigc_1_1mem__functor2.html#aeee1c7f263f8d7e7b6fa9be0156878fe">More...</a><br /></td></tr>
+<tr class="separator:aeee1c7f263f8d7e7b6fa9be0156878fe"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a6fe02ecb626919c1149888b03fde552e"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor2.html#a6fe02ecb626919c1149888b03fde552e">operator()</a> (T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:a6fe02ecb626919c1149888b03fde552e"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor2.html#a6fe02ecb626919c1149888b03fde552e">More...</a><br /></td></tr>
+<tr class="separator:a6fe02ecb626919c1149888b03fde552e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad5d0f74803537d1ed8b9678ac2da57d5"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor2.html#ad5d0f74803537d1ed8b9678ac2da57d5">operator()</a> (T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:ad5d0f74803537d1ed8b9678ac2da57d5"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor2.html#ad5d0f74803537d1ed8b9678ac2da57d5">More...</a><br /></td></tr>
+<tr class="separator:ad5d0f74803537d1ed8b9678ac2da57d5"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:aa4b00e1d6bb65c1c1791d314b5dcb4d6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor2.html#aa584cfe15bb8dc5b2931d2bfd034c118">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor2.html#aa4b00e1d6bb65c1c1791d314b5dcb4d6">func_ptr_</a></td></tr>
+<tr class="separator:aa4b00e1d6bb65c1c1791d314b5dcb4d6"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2><br />
+class sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></h3>
+
+<p><a class="el" href="classsigc_1_1mem__functor2.html" title="mem_functor2 wraps methods with 2 argument(s).">mem_functor2</a> wraps methods with 2 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1mem__functor2.html" title="mem_functor2 wraps methods with 2 argument(s).">mem_functor2</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1mem__functor2.html#ad5d0f74803537d1ed8b9678ac2da57d5" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1mem__functor2.html#ad5d0f74803537d1ed8b9678ac2da57d5" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1mem__functor2.html#ad5d0f74803537d1ed8b9678ac2da57d5" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="aa584cfe15bb8dc5b2931d2bfd034c118"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa584cfe15bb8dc5b2931d2bfd034c118">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1mem__functor2.html">sigc::mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::function_type) (T_arg1, T_arg2)</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a9080e942d35d226ea6f9dda097342f07"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9080e942d35d226ea6f9dda097342f07">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1mem__functor2.html">sigc::mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1mem__functor2.html#a9080e942d35d226ea6f9dda097342f07">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a691e21d47b7a54b67605812f7e089299"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a691e21d47b7a54b67605812f7e089299">◆ </a></span>mem_functor2() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor2.html">sigc::mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1mem__functor2.html">mem_functor2</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="aeee1c7f263f8d7e7b6fa9be0156878fe"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aeee1c7f263f8d7e7b6fa9be0156878fe">◆ </a></span>mem_functor2() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor2.html">sigc::mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1mem__functor2.html">mem_functor2</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1mem__functor2.html#aa584cfe15bb8dc5b2931d2bfd034c118">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1mem__functor2.html" title="mem_functor2 wraps methods with 2 argument(s).">mem_functor2</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1mem__functor2.html#ad5d0f74803537d1ed8b9678ac2da57d5" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a6fe02ecb626919c1149888b03fde552e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a6fe02ecb626919c1149888b03fde552e">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1mem__functor2.html">sigc::mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="ad5d0f74803537d1ed8b9678ac2da57d5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad5d0f74803537d1ed8b9678ac2da57d5">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1mem__functor2.html">sigc::mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000132">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="aa4b00e1d6bb65c1c1791d314b5dcb4d6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa4b00e1d6bb65c1c1791d314b5dcb4d6">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor2.html#aa584cfe15bb8dc5b2931d2bfd034c118">function_type</a> <a class="el" href="classsigc_1_1mem__functor2.html">sigc::mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 >" name="sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 >">
+<area shape="rect" id="node1" title="mem_functor2 wraps methods with 2 argument(s)." alt="" coords="29,80,180,136"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__mem__functor2.html" title="bound_mem_functor2 encapsulates a method with 2 arguments and an object instance." alt="" coords="5,184,204,240"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="35,5,175,32"/>
+</map>
--- /dev/null
+7eb86f2c2a308ab05b0782cf6055e7c5
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1mem__functor3.html">mem_functor3</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1mem__functor3.html">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor3.html#ac7ed881bf6b6ef8c7ed418ad3bfc0ccc">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1mem__functor3.html">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor3.html#a8da99a5dcfe5ae1cecd6ce93ab91b929">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor3.html">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor3.html#abc94be96c346537bca09c73a342f5ccd">mem_functor3</a>()</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor3.html">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor3.html#af22e274e905262144832ca9683d8823f">mem_functor3</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor3.html">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor3.html#ae7496f451661d60b287d528a7cfcaf82">operator()</a>(T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor3.html">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor3.html#a12319d24e245cf126c130de8202d91bf">operator()</a>(T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor3.html">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor3.html#af620103fa36aa86fb539843f7f730e01">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor3.html">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1mem__functor3.html">mem_functor3</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1mem__functor3-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1mem__functor3.html" title="mem_functor3 wraps methods with 3 argument(s).">mem_functor3</a> wraps methods with 3 argument(s).
+ <a href="classsigc_1_1mem__functor3.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1mem__functor3__inherit__graph.png" border="0" usemap="#asigc_1_1mem__functor3_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1mem__functor3_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_01_4_inherit__map" id="asigc_1_1mem__functor3_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_01_4_inherit__map">
+<area shape="rect" title="mem_functor3 wraps methods with 3 argument(s)." alt="" coords="16,80,193,136"/>
+<area shape="rect" href="classsigc_1_1bound__mem__functor3.html" title="bound_mem_functor3 encapsulates a method with 3 arguments and an object instance." alt="" coords="5,184,204,240"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="35,5,175,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a8da99a5dcfe5ae1cecd6ce93ab91b929"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor3.html#a8da99a5dcfe5ae1cecd6ce93ab91b929">function_type</a>) (T_arg1, T_arg2, T_arg3)</td></tr>
+<tr class="separator:a8da99a5dcfe5ae1cecd6ce93ab91b929"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af620103fa36aa86fb539843f7f730e01"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor3.html#af620103fa36aa86fb539843f7f730e01">result_type</a></td></tr>
+<tr class="separator:af620103fa36aa86fb539843f7f730e01"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:abc94be96c346537bca09c73a342f5ccd"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor3.html#abc94be96c346537bca09c73a342f5ccd">mem_functor3</a> ()</td></tr>
+<tr class="memdesc:abc94be96c346537bca09c73a342f5ccd"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1mem__functor3.html#abc94be96c346537bca09c73a342f5ccd">More...</a><br /></td></tr>
+<tr class="separator:abc94be96c346537bca09c73a342f5ccd"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af22e274e905262144832ca9683d8823f"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor3.html#af22e274e905262144832ca9683d8823f">mem_functor3</a> (<a class="el" href="classsigc_1_1mem__functor3.html#a8da99a5dcfe5ae1cecd6ce93ab91b929">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:af22e274e905262144832ca9683d8823f"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1mem__functor3.html" title="mem_functor3 wraps methods with 3 argument(s).">mem_functor3</a> object that wraps the passed method. <a href="classsigc_1_1mem__functor3.html#af22e274e905262144832ca9683d8823f">More...</a><br /></td></tr>
+<tr class="separator:af22e274e905262144832ca9683d8823f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a12319d24e245cf126c130de8202d91bf"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor3.html#a12319d24e245cf126c130de8202d91bf">operator()</a> (T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:a12319d24e245cf126c130de8202d91bf"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor3.html#a12319d24e245cf126c130de8202d91bf">More...</a><br /></td></tr>
+<tr class="separator:a12319d24e245cf126c130de8202d91bf"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae7496f451661d60b287d528a7cfcaf82"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor3.html#ae7496f451661d60b287d528a7cfcaf82">operator()</a> (T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:ae7496f451661d60b287d528a7cfcaf82"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor3.html#ae7496f451661d60b287d528a7cfcaf82">More...</a><br /></td></tr>
+<tr class="separator:ae7496f451661d60b287d528a7cfcaf82"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:ac7ed881bf6b6ef8c7ed418ad3bfc0ccc"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor3.html#a8da99a5dcfe5ae1cecd6ce93ab91b929">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor3.html#ac7ed881bf6b6ef8c7ed418ad3bfc0ccc">func_ptr_</a></td></tr>
+<tr class="separator:ac7ed881bf6b6ef8c7ed418ad3bfc0ccc"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3><br />
+class sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></h3>
+
+<p><a class="el" href="classsigc_1_1mem__functor3.html" title="mem_functor3 wraps methods with 3 argument(s).">mem_functor3</a> wraps methods with 3 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1mem__functor3.html" title="mem_functor3 wraps methods with 3 argument(s).">mem_functor3</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1mem__functor3.html#ae7496f451661d60b287d528a7cfcaf82" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1mem__functor3.html#ae7496f451661d60b287d528a7cfcaf82" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1mem__functor3.html#ae7496f451661d60b287d528a7cfcaf82" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1mem__functor3.html#ae7496f451661d60b287d528a7cfcaf82" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a8da99a5dcfe5ae1cecd6ce93ab91b929"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8da99a5dcfe5ae1cecd6ce93ab91b929">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1mem__functor3.html">sigc::mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::function_type) (T_arg1, T_arg2, T_arg3)</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="af620103fa36aa86fb539843f7f730e01"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af620103fa36aa86fb539843f7f730e01">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1mem__functor3.html">sigc::mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1mem__functor3.html#af620103fa36aa86fb539843f7f730e01">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="abc94be96c346537bca09c73a342f5ccd"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abc94be96c346537bca09c73a342f5ccd">◆ </a></span>mem_functor3() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor3.html">sigc::mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1mem__functor3.html">mem_functor3</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="af22e274e905262144832ca9683d8823f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af22e274e905262144832ca9683d8823f">◆ </a></span>mem_functor3() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor3.html">sigc::mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1mem__functor3.html">mem_functor3</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1mem__functor3.html#a8da99a5dcfe5ae1cecd6ce93ab91b929">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1mem__functor3.html" title="mem_functor3 wraps methods with 3 argument(s).">mem_functor3</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1mem__functor3.html#ae7496f451661d60b287d528a7cfcaf82" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a12319d24e245cf126c130de8202d91bf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a12319d24e245cf126c130de8202d91bf">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1mem__functor3.html">sigc::mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="ae7496f451661d60b287d528a7cfcaf82"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae7496f451661d60b287d528a7cfcaf82">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1mem__functor3.html">sigc::mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000133">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="ac7ed881bf6b6ef8c7ed418ad3bfc0ccc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac7ed881bf6b6ef8c7ed418ad3bfc0ccc">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor3.html#a8da99a5dcfe5ae1cecd6ce93ab91b929">function_type</a> <a class="el" href="classsigc_1_1mem__functor3.html">sigc::mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >" name="sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >">
+<area shape="rect" id="node1" title="mem_functor3 wraps methods with 3 argument(s)." alt="" coords="16,80,193,136"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__mem__functor3.html" title="bound_mem_functor3 encapsulates a method with 3 arguments and an object instance." alt="" coords="5,184,204,240"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="35,5,175,32"/>
+</map>
--- /dev/null
+3b4c25b213e25761edca4f4f19f3c801
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1mem__functor4.html">mem_functor4</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1mem__functor4.html">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor4.html#a28282d9285ca1a2075fd8041905a6302">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1mem__functor4.html">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor4.html#a9dcf1ef95187c2588ecf2abb089cc7c8">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor4.html">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor4.html#a9774f0ab47d023f5bccdb9960c4fcdee">mem_functor4</a>()</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor4.html">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor4.html#a4f7841b2ccd26fac6c21bf04fc524e08">mem_functor4</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor4.html">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor4.html#aef140dac7b4876793fac8a006aad0a62">operator()</a>(T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor4.html">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor4.html#a37b49e119c9be15f15362fe44eadc6a2">operator()</a>(T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor4.html">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor4.html#a79bf0a3c25dbe6eb07829ee55ce5d664">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor4.html">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1mem__functor4.html">mem_functor4</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1mem__functor4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1mem__functor4.html" title="mem_functor4 wraps methods with 4 argument(s).">mem_functor4</a> wraps methods with 4 argument(s).
+ <a href="classsigc_1_1mem__functor4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1mem__functor4__inherit__graph.png" border="0" usemap="#asigc_1_1mem__functor4_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1mem__functor4_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_01_4_inherit__map" id="asigc_1_1mem__functor4_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_01_4_inherit__map">
+<area shape="rect" title="mem_functor4 wraps methods with 4 argument(s)." alt="" coords="21,80,188,151"/>
+<area shape="rect" href="classsigc_1_1bound__mem__functor4.html" title="bound_mem_functor4 encapsulates a method with 4 arguments and an object instance." alt="" coords="5,199,204,255"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="35,5,175,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a9dcf1ef95187c2588ecf2abb089cc7c8"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor4.html#a9dcf1ef95187c2588ecf2abb089cc7c8">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4)</td></tr>
+<tr class="separator:a9dcf1ef95187c2588ecf2abb089cc7c8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a79bf0a3c25dbe6eb07829ee55ce5d664"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor4.html#a79bf0a3c25dbe6eb07829ee55ce5d664">result_type</a></td></tr>
+<tr class="separator:a79bf0a3c25dbe6eb07829ee55ce5d664"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a9774f0ab47d023f5bccdb9960c4fcdee"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor4.html#a9774f0ab47d023f5bccdb9960c4fcdee">mem_functor4</a> ()</td></tr>
+<tr class="memdesc:a9774f0ab47d023f5bccdb9960c4fcdee"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1mem__functor4.html#a9774f0ab47d023f5bccdb9960c4fcdee">More...</a><br /></td></tr>
+<tr class="separator:a9774f0ab47d023f5bccdb9960c4fcdee"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4f7841b2ccd26fac6c21bf04fc524e08"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor4.html#a4f7841b2ccd26fac6c21bf04fc524e08">mem_functor4</a> (<a class="el" href="classsigc_1_1mem__functor4.html#a9dcf1ef95187c2588ecf2abb089cc7c8">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a4f7841b2ccd26fac6c21bf04fc524e08"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1mem__functor4.html" title="mem_functor4 wraps methods with 4 argument(s).">mem_functor4</a> object that wraps the passed method. <a href="classsigc_1_1mem__functor4.html#a4f7841b2ccd26fac6c21bf04fc524e08">More...</a><br /></td></tr>
+<tr class="separator:a4f7841b2ccd26fac6c21bf04fc524e08"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a37b49e119c9be15f15362fe44eadc6a2"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor4.html#a37b49e119c9be15f15362fe44eadc6a2">operator()</a> (T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:a37b49e119c9be15f15362fe44eadc6a2"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor4.html#a37b49e119c9be15f15362fe44eadc6a2">More...</a><br /></td></tr>
+<tr class="separator:a37b49e119c9be15f15362fe44eadc6a2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aef140dac7b4876793fac8a006aad0a62"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor4.html#aef140dac7b4876793fac8a006aad0a62">operator()</a> (T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:aef140dac7b4876793fac8a006aad0a62"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor4.html#aef140dac7b4876793fac8a006aad0a62">More...</a><br /></td></tr>
+<tr class="separator:aef140dac7b4876793fac8a006aad0a62"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:a28282d9285ca1a2075fd8041905a6302"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor4.html#a9dcf1ef95187c2588ecf2abb089cc7c8">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor4.html#a28282d9285ca1a2075fd8041905a6302">func_ptr_</a></td></tr>
+<tr class="separator:a28282d9285ca1a2075fd8041905a6302"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4><br />
+class sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></h3>
+
+<p><a class="el" href="classsigc_1_1mem__functor4.html" title="mem_functor4 wraps methods with 4 argument(s).">mem_functor4</a> wraps methods with 4 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1mem__functor4.html" title="mem_functor4 wraps methods with 4 argument(s).">mem_functor4</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1mem__functor4.html#aef140dac7b4876793fac8a006aad0a62" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1mem__functor4.html#aef140dac7b4876793fac8a006aad0a62" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1mem__functor4.html#aef140dac7b4876793fac8a006aad0a62" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1mem__functor4.html#aef140dac7b4876793fac8a006aad0a62" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1mem__functor4.html#aef140dac7b4876793fac8a006aad0a62" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a9dcf1ef95187c2588ecf2abb089cc7c8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9dcf1ef95187c2588ecf2abb089cc7c8">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1mem__functor4.html">sigc::mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::function_type) (T_arg1, T_arg2, T_arg3, T_arg4)</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a79bf0a3c25dbe6eb07829ee55ce5d664"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a79bf0a3c25dbe6eb07829ee55ce5d664">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1mem__functor4.html">sigc::mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1mem__functor4.html#a79bf0a3c25dbe6eb07829ee55ce5d664">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a9774f0ab47d023f5bccdb9960c4fcdee"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9774f0ab47d023f5bccdb9960c4fcdee">◆ </a></span>mem_functor4() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor4.html">sigc::mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1mem__functor4.html">mem_functor4</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="a4f7841b2ccd26fac6c21bf04fc524e08"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4f7841b2ccd26fac6c21bf04fc524e08">◆ </a></span>mem_functor4() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor4.html">sigc::mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1mem__functor4.html">mem_functor4</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1mem__functor4.html#a9dcf1ef95187c2588ecf2abb089cc7c8">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1mem__functor4.html" title="mem_functor4 wraps methods with 4 argument(s).">mem_functor4</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1mem__functor4.html#aef140dac7b4876793fac8a006aad0a62" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a37b49e119c9be15f15362fe44eadc6a2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a37b49e119c9be15f15362fe44eadc6a2">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1mem__functor4.html">sigc::mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="aef140dac7b4876793fac8a006aad0a62"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aef140dac7b4876793fac8a006aad0a62">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1mem__functor4.html">sigc::mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000134">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a28282d9285ca1a2075fd8041905a6302"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a28282d9285ca1a2075fd8041905a6302">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor4.html#a9dcf1ef95187c2588ecf2abb089cc7c8">function_type</a> <a class="el" href="classsigc_1_1mem__functor4.html">sigc::mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >" name="sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >">
+<area shape="rect" id="node1" title="mem_functor4 wraps methods with 4 argument(s)." alt="" coords="21,80,188,151"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__mem__functor4.html" title="bound_mem_functor4 encapsulates a method with 4 arguments and an object instance." alt="" coords="5,199,204,255"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="35,5,175,32"/>
+</map>
--- /dev/null
+5007088c99d640c5242040e889a6f209
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1mem__functor5.html">mem_functor5</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1mem__functor5.html">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor5.html#a73a58b713dccc6a48b0083063b0df719">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1mem__functor5.html">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor5.html#a66e9bb0c9829b13af029ee2127b54eb5">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor5.html">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor5.html#a9048a4a2216e20f9f34380020f5b67ec">mem_functor5</a>()</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor5.html">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor5.html#a01bdff47bf4aed8c52fdfd5520fdf3cf">mem_functor5</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor5.html">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor5.html#a7ad7a4d81470125047755dfa8509c6dc">operator()</a>(T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor5.html">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor5.html#af1ce121edd0248d104f95e239af683bd">operator()</a>(T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor5.html">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor5.html#a3e0587ce338328d42f44c4e5f79be6ed">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor5.html">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1mem__functor5.html">mem_functor5</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1mem__functor5-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1mem__functor5.html" title="mem_functor5 wraps methods with 5 argument(s).">mem_functor5</a> wraps methods with 5 argument(s).
+ <a href="classsigc_1_1mem__functor5.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1mem__functor5__inherit__graph.png" border="0" usemap="#asigc_1_1mem__functor5_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1mem__functor5_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_01_4_inherit__map" id="asigc_1_1mem__functor5_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_01_4_inherit__map">
+<area shape="rect" title="mem_functor5 wraps methods with 5 argument(s)." alt="" coords="193,5,360,76"/>
+<area shape="rect" href="classsigc_1_1bound__mem__functor5.html" title="bound_mem_functor5 encapsulates a method with 5 arguments and an object instance." alt="" coords="408,5,607,76"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,27,145,54"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a66e9bb0c9829b13af029ee2127b54eb5"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor5.html#a66e9bb0c9829b13af029ee2127b54eb5">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)</td></tr>
+<tr class="separator:a66e9bb0c9829b13af029ee2127b54eb5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3e0587ce338328d42f44c4e5f79be6ed"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor5.html#a3e0587ce338328d42f44c4e5f79be6ed">result_type</a></td></tr>
+<tr class="separator:a3e0587ce338328d42f44c4e5f79be6ed"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a9048a4a2216e20f9f34380020f5b67ec"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor5.html#a9048a4a2216e20f9f34380020f5b67ec">mem_functor5</a> ()</td></tr>
+<tr class="memdesc:a9048a4a2216e20f9f34380020f5b67ec"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1mem__functor5.html#a9048a4a2216e20f9f34380020f5b67ec">More...</a><br /></td></tr>
+<tr class="separator:a9048a4a2216e20f9f34380020f5b67ec"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a01bdff47bf4aed8c52fdfd5520fdf3cf"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor5.html#a01bdff47bf4aed8c52fdfd5520fdf3cf">mem_functor5</a> (<a class="el" href="classsigc_1_1mem__functor5.html#a66e9bb0c9829b13af029ee2127b54eb5">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a01bdff47bf4aed8c52fdfd5520fdf3cf"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1mem__functor5.html" title="mem_functor5 wraps methods with 5 argument(s).">mem_functor5</a> object that wraps the passed method. <a href="classsigc_1_1mem__functor5.html#a01bdff47bf4aed8c52fdfd5520fdf3cf">More...</a><br /></td></tr>
+<tr class="separator:a01bdff47bf4aed8c52fdfd5520fdf3cf"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af1ce121edd0248d104f95e239af683bd"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor5.html#af1ce121edd0248d104f95e239af683bd">operator()</a> (T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:af1ce121edd0248d104f95e239af683bd"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor5.html#af1ce121edd0248d104f95e239af683bd">More...</a><br /></td></tr>
+<tr class="separator:af1ce121edd0248d104f95e239af683bd"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7ad7a4d81470125047755dfa8509c6dc"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor5.html#a7ad7a4d81470125047755dfa8509c6dc">operator()</a> (T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:a7ad7a4d81470125047755dfa8509c6dc"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor5.html#a7ad7a4d81470125047755dfa8509c6dc">More...</a><br /></td></tr>
+<tr class="separator:a7ad7a4d81470125047755dfa8509c6dc"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:a73a58b713dccc6a48b0083063b0df719"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor5.html#a66e9bb0c9829b13af029ee2127b54eb5">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor5.html#a73a58b713dccc6a48b0083063b0df719">func_ptr_</a></td></tr>
+<tr class="separator:a73a58b713dccc6a48b0083063b0df719"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5><br />
+class sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></h3>
+
+<p><a class="el" href="classsigc_1_1mem__functor5.html" title="mem_functor5 wraps methods with 5 argument(s).">mem_functor5</a> wraps methods with 5 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1mem__functor5.html" title="mem_functor5 wraps methods with 5 argument(s).">mem_functor5</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1mem__functor5.html#a7ad7a4d81470125047755dfa8509c6dc" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1mem__functor5.html#a7ad7a4d81470125047755dfa8509c6dc" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1mem__functor5.html#a7ad7a4d81470125047755dfa8509c6dc" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1mem__functor5.html#a7ad7a4d81470125047755dfa8509c6dc" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1mem__functor5.html#a7ad7a4d81470125047755dfa8509c6dc" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1mem__functor5.html#a7ad7a4d81470125047755dfa8509c6dc" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a66e9bb0c9829b13af029ee2127b54eb5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a66e9bb0c9829b13af029ee2127b54eb5">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1mem__functor5.html">sigc::mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::function_type) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a3e0587ce338328d42f44c4e5f79be6ed"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3e0587ce338328d42f44c4e5f79be6ed">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1mem__functor5.html">sigc::mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1mem__functor5.html#a3e0587ce338328d42f44c4e5f79be6ed">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a9048a4a2216e20f9f34380020f5b67ec"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9048a4a2216e20f9f34380020f5b67ec">◆ </a></span>mem_functor5() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor5.html">sigc::mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1mem__functor5.html">mem_functor5</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="a01bdff47bf4aed8c52fdfd5520fdf3cf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a01bdff47bf4aed8c52fdfd5520fdf3cf">◆ </a></span>mem_functor5() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor5.html">sigc::mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1mem__functor5.html">mem_functor5</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1mem__functor5.html#a66e9bb0c9829b13af029ee2127b54eb5">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1mem__functor5.html" title="mem_functor5 wraps methods with 5 argument(s).">mem_functor5</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1mem__functor5.html#a7ad7a4d81470125047755dfa8509c6dc" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="af1ce121edd0248d104f95e239af683bd"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af1ce121edd0248d104f95e239af683bd">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1mem__functor5.html">sigc::mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a7ad7a4d81470125047755dfa8509c6dc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7ad7a4d81470125047755dfa8509c6dc">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1mem__functor5.html">sigc::mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000135">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a73a58b713dccc6a48b0083063b0df719"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a73a58b713dccc6a48b0083063b0df719">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor5.html#a66e9bb0c9829b13af029ee2127b54eb5">function_type</a> <a class="el" href="classsigc_1_1mem__functor5.html">sigc::mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >" name="sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >">
+<area shape="rect" id="node1" title="mem_functor5 wraps methods with 5 argument(s)." alt="" coords="193,5,360,76"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__mem__functor5.html" title="bound_mem_functor5 encapsulates a method with 5 arguments and an object instance." alt="" coords="408,5,607,76"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,27,145,54"/>
+</map>
--- /dev/null
+7ad5814633f4183a0d11fcf18bce569e
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1mem__functor6.html">mem_functor6</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1mem__functor6.html">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor6.html#af07a44f7435cf15228903b0868fac956">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1mem__functor6.html">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor6.html#a202287b72f6213f64a696b185fb90268">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor6.html">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor6.html#aaa43195f4b4e39c76c10478539d35172">mem_functor6</a>()</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor6.html">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor6.html#aabc6bb723e0831e27a0a9131525d96bc">mem_functor6</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor6.html">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor6.html#afc40dbe8ea11726018dfa7c1ca435f3d">operator()</a>(T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor6.html">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor6.html#a4a322216c1783eb8ad7f63972b3a1164">operator()</a>(T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor6.html">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor6.html#af80425ff57ca2115cba771c275f49e36">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor6.html">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1mem__functor6.html">mem_functor6</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1mem__functor6-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1mem__functor6.html" title="mem_functor6 wraps methods with 6 argument(s).">mem_functor6</a> wraps methods with 6 argument(s).
+ <a href="classsigc_1_1mem__functor6.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1mem__functor6__inherit__graph.png" border="0" usemap="#asigc_1_1mem__functor6_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1mem__functor6_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_01_4_inherit__map" id="asigc_1_1mem__functor6_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_01_4_inherit__map">
+<area shape="rect" title="mem_functor6 wraps methods with 6 argument(s)." alt="" coords="193,5,383,76"/>
+<area shape="rect" href="classsigc_1_1bound__mem__functor6.html" title="bound_mem_functor6 encapsulates a method with 6 arguments and an object instance." alt="" coords="431,5,629,76"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,27,145,54"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a202287b72f6213f64a696b185fb90268"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor6.html#a202287b72f6213f64a696b185fb90268">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)</td></tr>
+<tr class="separator:a202287b72f6213f64a696b185fb90268"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af80425ff57ca2115cba771c275f49e36"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor6.html#af80425ff57ca2115cba771c275f49e36">result_type</a></td></tr>
+<tr class="separator:af80425ff57ca2115cba771c275f49e36"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:aaa43195f4b4e39c76c10478539d35172"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor6.html#aaa43195f4b4e39c76c10478539d35172">mem_functor6</a> ()</td></tr>
+<tr class="memdesc:aaa43195f4b4e39c76c10478539d35172"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1mem__functor6.html#aaa43195f4b4e39c76c10478539d35172">More...</a><br /></td></tr>
+<tr class="separator:aaa43195f4b4e39c76c10478539d35172"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aabc6bb723e0831e27a0a9131525d96bc"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor6.html#aabc6bb723e0831e27a0a9131525d96bc">mem_functor6</a> (<a class="el" href="classsigc_1_1mem__functor6.html#a202287b72f6213f64a696b185fb90268">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:aabc6bb723e0831e27a0a9131525d96bc"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1mem__functor6.html" title="mem_functor6 wraps methods with 6 argument(s).">mem_functor6</a> object that wraps the passed method. <a href="classsigc_1_1mem__functor6.html#aabc6bb723e0831e27a0a9131525d96bc">More...</a><br /></td></tr>
+<tr class="separator:aabc6bb723e0831e27a0a9131525d96bc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4a322216c1783eb8ad7f63972b3a1164"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor6.html#a4a322216c1783eb8ad7f63972b3a1164">operator()</a> (T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:a4a322216c1783eb8ad7f63972b3a1164"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor6.html#a4a322216c1783eb8ad7f63972b3a1164">More...</a><br /></td></tr>
+<tr class="separator:a4a322216c1783eb8ad7f63972b3a1164"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afc40dbe8ea11726018dfa7c1ca435f3d"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor6.html#afc40dbe8ea11726018dfa7c1ca435f3d">operator()</a> (T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:afc40dbe8ea11726018dfa7c1ca435f3d"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor6.html#afc40dbe8ea11726018dfa7c1ca435f3d">More...</a><br /></td></tr>
+<tr class="separator:afc40dbe8ea11726018dfa7c1ca435f3d"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:af07a44f7435cf15228903b0868fac956"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor6.html#a202287b72f6213f64a696b185fb90268">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor6.html#af07a44f7435cf15228903b0868fac956">func_ptr_</a></td></tr>
+<tr class="separator:af07a44f7435cf15228903b0868fac956"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6><br />
+class sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></h3>
+
+<p><a class="el" href="classsigc_1_1mem__functor6.html" title="mem_functor6 wraps methods with 6 argument(s).">mem_functor6</a> wraps methods with 6 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1mem__functor6.html" title="mem_functor6 wraps methods with 6 argument(s).">mem_functor6</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1mem__functor6.html#afc40dbe8ea11726018dfa7c1ca435f3d" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1mem__functor6.html#afc40dbe8ea11726018dfa7c1ca435f3d" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1mem__functor6.html#afc40dbe8ea11726018dfa7c1ca435f3d" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1mem__functor6.html#afc40dbe8ea11726018dfa7c1ca435f3d" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1mem__functor6.html#afc40dbe8ea11726018dfa7c1ca435f3d" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg6</em> Argument type used in the definition of <a class="el" href="classsigc_1_1mem__functor6.html#afc40dbe8ea11726018dfa7c1ca435f3d" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1mem__functor6.html#afc40dbe8ea11726018dfa7c1ca435f3d" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a202287b72f6213f64a696b185fb90268"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a202287b72f6213f64a696b185fb90268">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1mem__functor6.html">sigc::mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::function_type) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="af80425ff57ca2115cba771c275f49e36"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af80425ff57ca2115cba771c275f49e36">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1mem__functor6.html">sigc::mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1mem__functor6.html#af80425ff57ca2115cba771c275f49e36">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="aaa43195f4b4e39c76c10478539d35172"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aaa43195f4b4e39c76c10478539d35172">◆ </a></span>mem_functor6() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor6.html">sigc::mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1mem__functor6.html">mem_functor6</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="aabc6bb723e0831e27a0a9131525d96bc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aabc6bb723e0831e27a0a9131525d96bc">◆ </a></span>mem_functor6() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor6.html">sigc::mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1mem__functor6.html">mem_functor6</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1mem__functor6.html#a202287b72f6213f64a696b185fb90268">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1mem__functor6.html" title="mem_functor6 wraps methods with 6 argument(s).">mem_functor6</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1mem__functor6.html#afc40dbe8ea11726018dfa7c1ca435f3d" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a4a322216c1783eb8ad7f63972b3a1164"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4a322216c1783eb8ad7f63972b3a1164">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1mem__functor6.html">sigc::mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="afc40dbe8ea11726018dfa7c1ca435f3d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#afc40dbe8ea11726018dfa7c1ca435f3d">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1mem__functor6.html">sigc::mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000136">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="af07a44f7435cf15228903b0868fac956"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af07a44f7435cf15228903b0868fac956">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor6.html#a202287b72f6213f64a696b185fb90268">function_type</a> <a class="el" href="classsigc_1_1mem__functor6.html">sigc::mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >" name="sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >">
+<area shape="rect" id="node1" title="mem_functor6 wraps methods with 6 argument(s)." alt="" coords="193,5,383,76"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__mem__functor6.html" title="bound_mem_functor6 encapsulates a method with 6 arguments and an object instance." alt="" coords="431,5,629,76"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,27,145,54"/>
+</map>
--- /dev/null
+6754a713c7daf082b1c9ebf8690a3282
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1mem__functor7.html">mem_functor7</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1mem__functor7.html">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor7.html#a779c41d697c3b80d08a06cbcc9a5ea25">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1mem__functor7.html">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor7.html#a408f0afec5b4c750ca8e1bdab0f8b535">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor7.html">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor7.html#afbb9b8ecaa25e0dd85c0f3d539f198b4">mem_functor7</a>()</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor7.html">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor7.html#a79de1ccebb568e82b7f7a67ab85e4dc6">mem_functor7</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor7.html">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor7.html#ab95293e358caf96b5dbf123f024eed8d">operator()</a>(T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor7.html">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1mem__functor7.html#ad8e9031dc12742265d834a5529b1f00d">operator()</a>(T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor7.html">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1mem__functor7.html#a967b5f6572e988ea0833818b993745f9">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1mem__functor7.html">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1mem__functor7.html">mem_functor7</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1mem__functor7-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1mem__functor7.html" title="mem_functor7 wraps methods with 7 argument(s).">mem_functor7</a> wraps methods with 7 argument(s).
+ <a href="classsigc_1_1mem__functor7.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1mem__functor7__inherit__graph.png" border="0" usemap="#asigc_1_1mem__functor7_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1mem__functor7_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map" id="asigc_1_1mem__functor7_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map">
+<area shape="rect" title="mem_functor7 wraps methods with 7 argument(s)." alt="" coords="193,5,372,91"/>
+<area shape="rect" href="classsigc_1_1bound__mem__functor7.html" title="bound_mem_functor7 encapsulates a method with 7 arguments and an object instance." alt="" coords="420,13,619,83"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,35,145,61"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a408f0afec5b4c750ca8e1bdab0f8b535"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor7.html#a408f0afec5b4c750ca8e1bdab0f8b535">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)</td></tr>
+<tr class="separator:a408f0afec5b4c750ca8e1bdab0f8b535"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a967b5f6572e988ea0833818b993745f9"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor7.html#a967b5f6572e988ea0833818b993745f9">result_type</a></td></tr>
+<tr class="separator:a967b5f6572e988ea0833818b993745f9"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:afbb9b8ecaa25e0dd85c0f3d539f198b4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor7.html#afbb9b8ecaa25e0dd85c0f3d539f198b4">mem_functor7</a> ()</td></tr>
+<tr class="memdesc:afbb9b8ecaa25e0dd85c0f3d539f198b4"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1mem__functor7.html#afbb9b8ecaa25e0dd85c0f3d539f198b4">More...</a><br /></td></tr>
+<tr class="separator:afbb9b8ecaa25e0dd85c0f3d539f198b4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a79de1ccebb568e82b7f7a67ab85e4dc6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor7.html#a79de1ccebb568e82b7f7a67ab85e4dc6">mem_functor7</a> (<a class="el" href="classsigc_1_1mem__functor7.html#a408f0afec5b4c750ca8e1bdab0f8b535">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a79de1ccebb568e82b7f7a67ab85e4dc6"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1mem__functor7.html" title="mem_functor7 wraps methods with 7 argument(s).">mem_functor7</a> object that wraps the passed method. <a href="classsigc_1_1mem__functor7.html#a79de1ccebb568e82b7f7a67ab85e4dc6">More...</a><br /></td></tr>
+<tr class="separator:a79de1ccebb568e82b7f7a67ab85e4dc6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad8e9031dc12742265d834a5529b1f00d"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor7.html#ad8e9031dc12742265d834a5529b1f00d">operator()</a> (T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:ad8e9031dc12742265d834a5529b1f00d"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor7.html#ad8e9031dc12742265d834a5529b1f00d">More...</a><br /></td></tr>
+<tr class="separator:ad8e9031dc12742265d834a5529b1f00d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab95293e358caf96b5dbf123f024eed8d"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor7.html#ab95293e358caf96b5dbf123f024eed8d">operator()</a> (T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:ab95293e358caf96b5dbf123f024eed8d"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1mem__functor7.html#ab95293e358caf96b5dbf123f024eed8d">More...</a><br /></td></tr>
+<tr class="separator:ab95293e358caf96b5dbf123f024eed8d"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:a779c41d697c3b80d08a06cbcc9a5ea25"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor7.html#a408f0afec5b4c750ca8e1bdab0f8b535">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor7.html#a779c41d697c3b80d08a06cbcc9a5ea25">func_ptr_</a></td></tr>
+<tr class="separator:a779c41d697c3b80d08a06cbcc9a5ea25"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7><br />
+class sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></h3>
+
+<p><a class="el" href="classsigc_1_1mem__functor7.html" title="mem_functor7 wraps methods with 7 argument(s).">mem_functor7</a> wraps methods with 7 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1mem__functor7.html" title="mem_functor7 wraps methods with 7 argument(s).">mem_functor7</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1mem__functor7.html#ab95293e358caf96b5dbf123f024eed8d" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1mem__functor7.html#ab95293e358caf96b5dbf123f024eed8d" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1mem__functor7.html#ab95293e358caf96b5dbf123f024eed8d" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1mem__functor7.html#ab95293e358caf96b5dbf123f024eed8d" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1mem__functor7.html#ab95293e358caf96b5dbf123f024eed8d" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg6</em> Argument type used in the definition of <a class="el" href="classsigc_1_1mem__functor7.html#ab95293e358caf96b5dbf123f024eed8d" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg7</em> Argument type used in the definition of <a class="el" href="classsigc_1_1mem__functor7.html#ab95293e358caf96b5dbf123f024eed8d" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1mem__functor7.html#ab95293e358caf96b5dbf123f024eed8d" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a408f0afec5b4c750ca8e1bdab0f8b535"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a408f0afec5b4c750ca8e1bdab0f8b535">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1mem__functor7.html">sigc::mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::function_type) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a967b5f6572e988ea0833818b993745f9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a967b5f6572e988ea0833818b993745f9">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1mem__functor7.html">sigc::mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1mem__functor7.html#a967b5f6572e988ea0833818b993745f9">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="afbb9b8ecaa25e0dd85c0f3d539f198b4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#afbb9b8ecaa25e0dd85c0f3d539f198b4">◆ </a></span>mem_functor7() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor7.html">sigc::mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1mem__functor7.html">mem_functor7</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="a79de1ccebb568e82b7f7a67ab85e4dc6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a79de1ccebb568e82b7f7a67ab85e4dc6">◆ </a></span>mem_functor7() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor7.html">sigc::mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1mem__functor7.html">mem_functor7</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1mem__functor7.html#a408f0afec5b4c750ca8e1bdab0f8b535">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1mem__functor7.html" title="mem_functor7 wraps methods with 7 argument(s).">mem_functor7</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1mem__functor7.html#ab95293e358caf96b5dbf123f024eed8d" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="ad8e9031dc12742265d834a5529b1f00d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad8e9031dc12742265d834a5529b1f00d">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1mem__functor7.html">sigc::mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > </td>
+ <td class="paramname"><em>_A_a7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a7</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="ab95293e358caf96b5dbf123f024eed8d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab95293e358caf96b5dbf123f024eed8d">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1mem__functor7.html">sigc::mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > </td>
+ <td class="paramname"><em>_A_a7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000137">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a7</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a779c41d697c3b80d08a06cbcc9a5ea25"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a779c41d697c3b80d08a06cbcc9a5ea25">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor7.html#a408f0afec5b4c750ca8e1bdab0f8b535">function_type</a> <a class="el" href="classsigc_1_1mem__functor7.html">sigc::mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >" name="sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >">
+<area shape="rect" id="node1" title="mem_functor7 wraps methods with 7 argument(s)." alt="" coords="193,5,372,91"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__mem__functor7.html" title="bound_mem_functor7 encapsulates a method with 7 arguments and an object instance." alt="" coords="420,13,619,83"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,35,145,61"/>
+</map>
--- /dev/null
+598b3477c1b5ede5499e77768dd09a4d
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1pointer__functor0.html">pointer_functor0</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::pointer_functor0< T_return > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1pointer__functor0.html">sigc::pointer_functor0< T_return ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1pointer__functor0.html#af998b64dac7b3c7eeb2e9a2856a4213e">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor0.html">sigc::pointer_functor0< T_return ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1pointer__functor0.html#a56db821303c19ec3345679d80d6ef96e">operator()</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor0.html">sigc::pointer_functor0< T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1pointer__functor0.html#afdb67f682e7b9190f646eed879dcfbe4">pointer_functor0</a>()</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor0.html">sigc::pointer_functor0< T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1pointer__functor0.html#a9ae3efd5c13c738db815f619499004d7">pointer_functor0</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor0.html">sigc::pointer_functor0< T_return ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1pointer__functor0.html#af44316e53e33b4184ca151b6b11c70e5">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor0.html">sigc::pointer_functor0< T_return ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::pointer_functor0< T_return > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1pointer__functor0.html">pointer_functor0</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1pointer__functor0-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::pointer_functor0< T_return > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__ptr__fun.html">ptr_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1pointer__functor0.html" title="pointer_functor0 wraps existing non-member functions with 0 argument(s).">pointer_functor0</a> wraps existing non-member functions with 0 argument(s).
+ <a href="classsigc_1_1pointer__functor0.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/ptr_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::pointer_functor0< T_return >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1pointer__functor0__inherit__graph.png" border="0" usemap="#asigc_1_1pointer__functor0_3_01T__return_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1pointer__functor0_3_01T__return_01_4_inherit__map" id="asigc_1_1pointer__functor0_3_01T__return_01_4_inherit__map">
+<area shape="rect" title="pointer_functor0 wraps existing non-member functions with 0 argument(s)." alt="" coords="5,80,168,121"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="17,5,157,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:af44316e53e33b4184ca151b6b11c70e5"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor0.html#af44316e53e33b4184ca151b6b11c70e5">result_type</a></td></tr>
+<tr class="separator:af44316e53e33b4184ca151b6b11c70e5"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:afdb67f682e7b9190f646eed879dcfbe4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor0.html#afdb67f682e7b9190f646eed879dcfbe4">pointer_functor0</a> ()</td></tr>
+<tr class="memdesc:afdb67f682e7b9190f646eed879dcfbe4"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1pointer__functor0.html#afdb67f682e7b9190f646eed879dcfbe4">More...</a><br /></td></tr>
+<tr class="separator:afdb67f682e7b9190f646eed879dcfbe4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9ae3efd5c13c738db815f619499004d7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor0.html#a9ae3efd5c13c738db815f619499004d7">pointer_functor0</a> (function_type _A_func)</td></tr>
+<tr class="memdesc:a9ae3efd5c13c738db815f619499004d7"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1pointer__functor0.html" title="pointer_functor0 wraps existing non-member functions with 0 argument(s).">pointer_functor0</a> object that wraps an existing function. <a href="classsigc_1_1pointer__functor0.html#a9ae3efd5c13c738db815f619499004d7">More...</a><br /></td></tr>
+<tr class="separator:a9ae3efd5c13c738db815f619499004d7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a56db821303c19ec3345679d80d6ef96e"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor0.html#a56db821303c19ec3345679d80d6ef96e">operator()</a> () const</td></tr>
+<tr class="memdesc:a56db821303c19ec3345679d80d6ef96e"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped function. <a href="classsigc_1_1pointer__functor0.html#a56db821303c19ec3345679d80d6ef96e">More...</a><br /></td></tr>
+<tr class="separator:a56db821303c19ec3345679d80d6ef96e"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:af998b64dac7b3c7eeb2e9a2856a4213e"><td class="memItemLeft" align="right" valign="top">function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor0.html#af998b64dac7b3c7eeb2e9a2856a4213e">func_ptr_</a></td></tr>
+<tr class="separator:af998b64dac7b3c7eeb2e9a2856a4213e"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return><br />
+class sigc::pointer_functor0< T_return ></h3>
+
+<p><a class="el" href="classsigc_1_1pointer__functor0.html" title="pointer_functor0 wraps existing non-member functions with 0 argument(s).">pointer_functor0</a> wraps existing non-member functions with 0 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863" title="Creates a functor of type sigc::pointer_functor0 which wraps an existing non-member function.">ptr_fun()</a> to create an instance of <a class="el" href="classsigc_1_1pointer__functor0.html" title="pointer_functor0 wraps existing non-member functions with 0 argument(s).">pointer_functor0</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1pointer__functor0.html#a56db821303c19ec3345679d80d6ef96e" title="Execute the wrapped function.">operator()()</a>. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="af44316e53e33b4184ca151b6b11c70e5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af44316e53e33b4184ca151b6b11c70e5">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1pointer__functor0.html">sigc::pointer_functor0</a>< T_return >::<a class="el" href="classsigc_1_1pointer__functor0.html#af44316e53e33b4184ca151b6b11c70e5">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="afdb67f682e7b9190f646eed879dcfbe4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#afdb67f682e7b9190f646eed879dcfbe4">◆ </a></span>pointer_functor0() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor0.html">sigc::pointer_functor0</a>< T_return >::<a class="el" href="classsigc_1_1pointer__functor0.html">pointer_functor0</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="a9ae3efd5c13c738db815f619499004d7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9ae3efd5c13c738db815f619499004d7">◆ </a></span>pointer_functor0() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor0.html">sigc::pointer_functor0</a>< T_return >::<a class="el" href="classsigc_1_1pointer__functor0.html">pointer_functor0</a> </td>
+ <td>(</td>
+ <td class="paramtype">function_type </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1pointer__functor0.html" title="pointer_functor0 wraps existing non-member functions with 0 argument(s).">pointer_functor0</a> object that wraps an existing function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to function that will be invoked from <a class="el" href="classsigc_1_1pointer__functor0.html#a56db821303c19ec3345679d80d6ef96e" title="Execute the wrapped function.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a56db821303c19ec3345679d80d6ef96e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a56db821303c19ec3345679d80d6ef96e">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1pointer__functor0.html">sigc::pointer_functor0</a>< T_return >::operator() </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped function. </p>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the function invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="af998b64dac7b3c7eeb2e9a2856a4213e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af998b64dac7b3c7eeb2e9a2856a4213e">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">function_type <a class="el" href="classsigc_1_1pointer__functor0.html">sigc::pointer_functor0</a>< T_return >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::pointer_functor0< T_return >" name="sigc::pointer_functor0< T_return >">
+<area shape="rect" id="node1" title="pointer_functor0 wraps existing non-member functions with 0 argument(s)." alt="" coords="5,80,168,121"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="17,5,157,32"/>
+</map>
--- /dev/null
+c9bdc4124d5171e31e4b349786a847f7
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1pointer__functor1.html">pointer_functor1</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::pointer_functor1< T_arg1, T_return > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1pointer__functor1.html">sigc::pointer_functor1< T_arg1, T_return ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1pointer__functor1.html#a864ab55240be5287faf07c341ae9501e">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor1.html">sigc::pointer_functor1< T_arg1, T_return ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1pointer__functor1.html#a3c978e35c107326078f3e33afcdd1235">operator()</a>(type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor1.html">sigc::pointer_functor1< T_arg1, T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1pointer__functor1.html#a6ce467c0641f8e3e0d91f3b843b07c3f">pointer_functor1</a>()</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor1.html">sigc::pointer_functor1< T_arg1, T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1pointer__functor1.html#a8ab0c5b707dc41a821c63769344db2cb">pointer_functor1</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor1.html">sigc::pointer_functor1< T_arg1, T_return ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1pointer__functor1.html#a4080910d23a74b102a123838fa93e90b">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor1.html">sigc::pointer_functor1< T_arg1, T_return ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::pointer_functor1< T_arg1, T_return > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1pointer__functor1.html">pointer_functor1</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1pointer__functor1-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::pointer_functor1< T_arg1, T_return > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__ptr__fun.html">ptr_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1pointer__functor1.html" title="pointer_functor1 wraps existing non-member functions with 1 argument(s).">pointer_functor1</a> wraps existing non-member functions with 1 argument(s).
+ <a href="classsigc_1_1pointer__functor1.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/ptr_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::pointer_functor1< T_arg1, T_return >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1pointer__functor1__inherit__graph.png" border="0" usemap="#asigc_1_1pointer__functor1_3_01T__arg1_00_01T__return_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1pointer__functor1_3_01T__arg1_00_01T__return_01_4_inherit__map" id="asigc_1_1pointer__functor1_3_01T__arg1_00_01T__return_01_4_inherit__map">
+<area shape="rect" title="pointer_functor1 wraps existing non-member functions with 1 argument(s)." alt="" coords="5,80,168,121"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="17,5,157,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a4080910d23a74b102a123838fa93e90b"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor1.html#a4080910d23a74b102a123838fa93e90b">result_type</a></td></tr>
+<tr class="separator:a4080910d23a74b102a123838fa93e90b"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a6ce467c0641f8e3e0d91f3b843b07c3f"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor1.html#a6ce467c0641f8e3e0d91f3b843b07c3f">pointer_functor1</a> ()</td></tr>
+<tr class="memdesc:a6ce467c0641f8e3e0d91f3b843b07c3f"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1pointer__functor1.html#a6ce467c0641f8e3e0d91f3b843b07c3f">More...</a><br /></td></tr>
+<tr class="separator:a6ce467c0641f8e3e0d91f3b843b07c3f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8ab0c5b707dc41a821c63769344db2cb"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor1.html#a8ab0c5b707dc41a821c63769344db2cb">pointer_functor1</a> (function_type _A_func)</td></tr>
+<tr class="memdesc:a8ab0c5b707dc41a821c63769344db2cb"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1pointer__functor1.html" title="pointer_functor1 wraps existing non-member functions with 1 argument(s).">pointer_functor1</a> object that wraps an existing function. <a href="classsigc_1_1pointer__functor1.html#a8ab0c5b707dc41a821c63769344db2cb">More...</a><br /></td></tr>
+<tr class="separator:a8ab0c5b707dc41a821c63769344db2cb"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3c978e35c107326078f3e33afcdd1235"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor1.html#a3c978e35c107326078f3e33afcdd1235">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a3c978e35c107326078f3e33afcdd1235"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped function. <a href="classsigc_1_1pointer__functor1.html#a3c978e35c107326078f3e33afcdd1235">More...</a><br /></td></tr>
+<tr class="separator:a3c978e35c107326078f3e33afcdd1235"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:a864ab55240be5287faf07c341ae9501e"><td class="memItemLeft" align="right" valign="top">function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor1.html#a864ab55240be5287faf07c341ae9501e">func_ptr_</a></td></tr>
+<tr class="separator:a864ab55240be5287faf07c341ae9501e"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_arg1, class T_return><br />
+class sigc::pointer_functor1< T_arg1, T_return ></h3>
+
+<p><a class="el" href="classsigc_1_1pointer__functor1.html" title="pointer_functor1 wraps existing non-member functions with 1 argument(s).">pointer_functor1</a> wraps existing non-member functions with 1 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863" title="Creates a functor of type sigc::pointer_functor0 which wraps an existing non-member function.">ptr_fun()</a> to create an instance of <a class="el" href="classsigc_1_1pointer__functor1.html" title="pointer_functor1 wraps existing non-member functions with 1 argument(s).">pointer_functor1</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1pointer__functor1.html#a3c978e35c107326078f3e33afcdd1235" title="Execute the wrapped function.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1pointer__functor1.html#a3c978e35c107326078f3e33afcdd1235" title="Execute the wrapped function.">operator()()</a>. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a4080910d23a74b102a123838fa93e90b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4080910d23a74b102a123838fa93e90b">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1pointer__functor1.html">sigc::pointer_functor1</a>< T_arg1, T_return >::<a class="el" href="classsigc_1_1pointer__functor1.html#a4080910d23a74b102a123838fa93e90b">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a6ce467c0641f8e3e0d91f3b843b07c3f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a6ce467c0641f8e3e0d91f3b843b07c3f">◆ </a></span>pointer_functor1() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor1.html">sigc::pointer_functor1</a>< T_arg1, T_return >::<a class="el" href="classsigc_1_1pointer__functor1.html">pointer_functor1</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="a8ab0c5b707dc41a821c63769344db2cb"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8ab0c5b707dc41a821c63769344db2cb">◆ </a></span>pointer_functor1() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor1.html">sigc::pointer_functor1</a>< T_arg1, T_return >::<a class="el" href="classsigc_1_1pointer__functor1.html">pointer_functor1</a> </td>
+ <td>(</td>
+ <td class="paramtype">function_type </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1pointer__functor1.html" title="pointer_functor1 wraps existing non-member functions with 1 argument(s).">pointer_functor1</a> object that wraps an existing function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to function that will be invoked from <a class="el" href="classsigc_1_1pointer__functor1.html#a3c978e35c107326078f3e33afcdd1235" title="Execute the wrapped function.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a3c978e35c107326078f3e33afcdd1235"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3c978e35c107326078f3e33afcdd1235">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1pointer__functor1.html">sigc::pointer_functor1</a>< T_arg1, T_return >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the function. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the function invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a864ab55240be5287faf07c341ae9501e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a864ab55240be5287faf07c341ae9501e">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">function_type <a class="el" href="classsigc_1_1pointer__functor1.html">sigc::pointer_functor1</a>< T_arg1, T_return >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::pointer_functor1< T_arg1, T_return >" name="sigc::pointer_functor1< T_arg1, T_return >">
+<area shape="rect" id="node1" title="pointer_functor1 wraps existing non-member functions with 1 argument(s)." alt="" coords="5,80,168,121"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="17,5,157,32"/>
+</map>
--- /dev/null
+ffbd05ac9f23cee21e19c389f0da31db
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1pointer__functor2.html">pointer_functor2</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::pointer_functor2< T_arg1, T_arg2, T_return > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1pointer__functor2.html">sigc::pointer_functor2< T_arg1, T_arg2, T_return ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1pointer__functor2.html#a340680ba8ae5ea67eb0afe33d118c82b">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor2.html">sigc::pointer_functor2< T_arg1, T_arg2, T_return ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1pointer__functor2.html#af3d1d778be1730e170c42c52511d6926">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor2.html">sigc::pointer_functor2< T_arg1, T_arg2, T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1pointer__functor2.html#a2977aa1d72f5f0fd6c778b60ad791b9c">pointer_functor2</a>()</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor2.html">sigc::pointer_functor2< T_arg1, T_arg2, T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1pointer__functor2.html#a428226381ff7bda06044c8fa53d4e27e">pointer_functor2</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor2.html">sigc::pointer_functor2< T_arg1, T_arg2, T_return ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1pointer__functor2.html#a297b784eb0cea07b364c854e5dd5f864">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor2.html">sigc::pointer_functor2< T_arg1, T_arg2, T_return ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::pointer_functor2< T_arg1, T_arg2, T_return > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1pointer__functor2.html">pointer_functor2</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1pointer__functor2-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::pointer_functor2< T_arg1, T_arg2, T_return > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__ptr__fun.html">ptr_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1pointer__functor2.html" title="pointer_functor2 wraps existing non-member functions with 2 argument(s).">pointer_functor2</a> wraps existing non-member functions with 2 argument(s).
+ <a href="classsigc_1_1pointer__functor2.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/ptr_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::pointer_functor2< T_arg1, T_arg2, T_return >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1pointer__functor2__inherit__graph.png" border="0" usemap="#asigc_1_1pointer__functor2_3_01T__arg1_00_01T__arg2_00_01T__return_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1pointer__functor2_3_01T__arg1_00_01T__arg2_00_01T__return_01_4_inherit__map" id="asigc_1_1pointer__functor2_3_01T__arg1_00_01T__arg2_00_01T__return_01_4_inherit__map">
+<area shape="rect" title="pointer_functor2 wraps existing non-member functions with 2 argument(s)." alt="" coords="5,80,216,121"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="41,5,181,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a297b784eb0cea07b364c854e5dd5f864"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor2.html#a297b784eb0cea07b364c854e5dd5f864">result_type</a></td></tr>
+<tr class="separator:a297b784eb0cea07b364c854e5dd5f864"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a2977aa1d72f5f0fd6c778b60ad791b9c"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor2.html#a2977aa1d72f5f0fd6c778b60ad791b9c">pointer_functor2</a> ()</td></tr>
+<tr class="memdesc:a2977aa1d72f5f0fd6c778b60ad791b9c"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1pointer__functor2.html#a2977aa1d72f5f0fd6c778b60ad791b9c">More...</a><br /></td></tr>
+<tr class="separator:a2977aa1d72f5f0fd6c778b60ad791b9c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a428226381ff7bda06044c8fa53d4e27e"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor2.html#a428226381ff7bda06044c8fa53d4e27e">pointer_functor2</a> (function_type _A_func)</td></tr>
+<tr class="memdesc:a428226381ff7bda06044c8fa53d4e27e"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1pointer__functor2.html" title="pointer_functor2 wraps existing non-member functions with 2 argument(s).">pointer_functor2</a> object that wraps an existing function. <a href="classsigc_1_1pointer__functor2.html#a428226381ff7bda06044c8fa53d4e27e">More...</a><br /></td></tr>
+<tr class="separator:a428226381ff7bda06044c8fa53d4e27e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af3d1d778be1730e170c42c52511d6926"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor2.html#af3d1d778be1730e170c42c52511d6926">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:af3d1d778be1730e170c42c52511d6926"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped function. <a href="classsigc_1_1pointer__functor2.html#af3d1d778be1730e170c42c52511d6926">More...</a><br /></td></tr>
+<tr class="separator:af3d1d778be1730e170c42c52511d6926"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:a340680ba8ae5ea67eb0afe33d118c82b"><td class="memItemLeft" align="right" valign="top">function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor2.html#a340680ba8ae5ea67eb0afe33d118c82b">func_ptr_</a></td></tr>
+<tr class="separator:a340680ba8ae5ea67eb0afe33d118c82b"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_arg1, class T_arg2, class T_return><br />
+class sigc::pointer_functor2< T_arg1, T_arg2, T_return ></h3>
+
+<p><a class="el" href="classsigc_1_1pointer__functor2.html" title="pointer_functor2 wraps existing non-member functions with 2 argument(s).">pointer_functor2</a> wraps existing non-member functions with 2 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863" title="Creates a functor of type sigc::pointer_functor0 which wraps an existing non-member function.">ptr_fun()</a> to create an instance of <a class="el" href="classsigc_1_1pointer__functor2.html" title="pointer_functor2 wraps existing non-member functions with 2 argument(s).">pointer_functor2</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1pointer__functor2.html#af3d1d778be1730e170c42c52511d6926" title="Execute the wrapped function.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1pointer__functor2.html#af3d1d778be1730e170c42c52511d6926" title="Execute the wrapped function.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1pointer__functor2.html#af3d1d778be1730e170c42c52511d6926" title="Execute the wrapped function.">operator()()</a>. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a297b784eb0cea07b364c854e5dd5f864"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a297b784eb0cea07b364c854e5dd5f864">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1pointer__functor2.html">sigc::pointer_functor2</a>< T_arg1, T_arg2, T_return >::<a class="el" href="classsigc_1_1pointer__functor2.html#a297b784eb0cea07b364c854e5dd5f864">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a2977aa1d72f5f0fd6c778b60ad791b9c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2977aa1d72f5f0fd6c778b60ad791b9c">◆ </a></span>pointer_functor2() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor2.html">sigc::pointer_functor2</a>< T_arg1, T_arg2, T_return >::<a class="el" href="classsigc_1_1pointer__functor2.html">pointer_functor2</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="a428226381ff7bda06044c8fa53d4e27e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a428226381ff7bda06044c8fa53d4e27e">◆ </a></span>pointer_functor2() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor2.html">sigc::pointer_functor2</a>< T_arg1, T_arg2, T_return >::<a class="el" href="classsigc_1_1pointer__functor2.html">pointer_functor2</a> </td>
+ <td>(</td>
+ <td class="paramtype">function_type </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1pointer__functor2.html" title="pointer_functor2 wraps existing non-member functions with 2 argument(s).">pointer_functor2</a> object that wraps an existing function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to function that will be invoked from <a class="el" href="classsigc_1_1pointer__functor2.html#af3d1d778be1730e170c42c52511d6926" title="Execute the wrapped function.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="af3d1d778be1730e170c42c52511d6926"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af3d1d778be1730e170c42c52511d6926">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1pointer__functor2.html">sigc::pointer_functor2</a>< T_arg1, T_arg2, T_return >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the function. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the function. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the function invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a340680ba8ae5ea67eb0afe33d118c82b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a340680ba8ae5ea67eb0afe33d118c82b">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">function_type <a class="el" href="classsigc_1_1pointer__functor2.html">sigc::pointer_functor2</a>< T_arg1, T_arg2, T_return >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::pointer_functor2< T_arg1, T_arg2, T_return >" name="sigc::pointer_functor2< T_arg1, T_arg2, T_return >">
+<area shape="rect" id="node1" title="pointer_functor2 wraps existing non-member functions with 2 argument(s)." alt="" coords="5,80,216,121"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="41,5,181,32"/>
+</map>
--- /dev/null
+116a09082ea8d1a3d6c70a93cc340772
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1pointer__functor3.html">pointer_functor3</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::pointer_functor3< T_arg1, T_arg2, T_arg3, T_return > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1pointer__functor3.html">sigc::pointer_functor3< T_arg1, T_arg2, T_arg3, T_return ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1pointer__functor3.html#a1ac1e43f2515d64c0da4656cdfac1f44">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor3.html">sigc::pointer_functor3< T_arg1, T_arg2, T_arg3, T_return ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1pointer__functor3.html#adf560c1e583b2216bba4de3027e3a05e">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor3.html">sigc::pointer_functor3< T_arg1, T_arg2, T_arg3, T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1pointer__functor3.html#a1a4909d1444e4456a89eb5852933d1cc">pointer_functor3</a>()</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor3.html">sigc::pointer_functor3< T_arg1, T_arg2, T_arg3, T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1pointer__functor3.html#aae48103ba1c48e192a04c9a1b81ae9dc">pointer_functor3</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor3.html">sigc::pointer_functor3< T_arg1, T_arg2, T_arg3, T_return ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1pointer__functor3.html#a2a0ed29803c02cc62fcc6497f83f88bf">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor3.html">sigc::pointer_functor3< T_arg1, T_arg2, T_arg3, T_return ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::pointer_functor3< T_arg1, T_arg2, T_arg3, T_return > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1pointer__functor3.html">pointer_functor3</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1pointer__functor3-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::pointer_functor3< T_arg1, T_arg2, T_arg3, T_return > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__ptr__fun.html">ptr_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1pointer__functor3.html" title="pointer_functor3 wraps existing non-member functions with 3 argument(s).">pointer_functor3</a> wraps existing non-member functions with 3 argument(s).
+ <a href="classsigc_1_1pointer__functor3.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/ptr_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::pointer_functor3< T_arg1, T_arg2, T_arg3, T_return >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1pointer__functor3__inherit__graph.png" border="0" usemap="#asigc_1_1pointer__functor3_3_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__return_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1pointer__functor3_3_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__return_01_4_inherit__map" id="asigc_1_1pointer__functor3_3_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__return_01_4_inherit__map">
+<area shape="rect" title="pointer_functor3 wraps existing non-member functions with 3 argument(s)." alt="" coords="5,80,195,136"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="30,5,170,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a2a0ed29803c02cc62fcc6497f83f88bf"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor3.html#a2a0ed29803c02cc62fcc6497f83f88bf">result_type</a></td></tr>
+<tr class="separator:a2a0ed29803c02cc62fcc6497f83f88bf"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a1a4909d1444e4456a89eb5852933d1cc"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor3.html#a1a4909d1444e4456a89eb5852933d1cc">pointer_functor3</a> ()</td></tr>
+<tr class="memdesc:a1a4909d1444e4456a89eb5852933d1cc"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1pointer__functor3.html#a1a4909d1444e4456a89eb5852933d1cc">More...</a><br /></td></tr>
+<tr class="separator:a1a4909d1444e4456a89eb5852933d1cc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aae48103ba1c48e192a04c9a1b81ae9dc"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor3.html#aae48103ba1c48e192a04c9a1b81ae9dc">pointer_functor3</a> (function_type _A_func)</td></tr>
+<tr class="memdesc:aae48103ba1c48e192a04c9a1b81ae9dc"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1pointer__functor3.html" title="pointer_functor3 wraps existing non-member functions with 3 argument(s).">pointer_functor3</a> object that wraps an existing function. <a href="classsigc_1_1pointer__functor3.html#aae48103ba1c48e192a04c9a1b81ae9dc">More...</a><br /></td></tr>
+<tr class="separator:aae48103ba1c48e192a04c9a1b81ae9dc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adf560c1e583b2216bba4de3027e3a05e"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor3.html#adf560c1e583b2216bba4de3027e3a05e">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:adf560c1e583b2216bba4de3027e3a05e"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped function. <a href="classsigc_1_1pointer__functor3.html#adf560c1e583b2216bba4de3027e3a05e">More...</a><br /></td></tr>
+<tr class="separator:adf560c1e583b2216bba4de3027e3a05e"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:a1ac1e43f2515d64c0da4656cdfac1f44"><td class="memItemLeft" align="right" valign="top">function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor3.html#a1ac1e43f2515d64c0da4656cdfac1f44">func_ptr_</a></td></tr>
+<tr class="separator:a1ac1e43f2515d64c0da4656cdfac1f44"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_arg1, class T_arg2, class T_arg3, class T_return><br />
+class sigc::pointer_functor3< T_arg1, T_arg2, T_arg3, T_return ></h3>
+
+<p><a class="el" href="classsigc_1_1pointer__functor3.html" title="pointer_functor3 wraps existing non-member functions with 3 argument(s).">pointer_functor3</a> wraps existing non-member functions with 3 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863" title="Creates a functor of type sigc::pointer_functor0 which wraps an existing non-member function.">ptr_fun()</a> to create an instance of <a class="el" href="classsigc_1_1pointer__functor3.html" title="pointer_functor3 wraps existing non-member functions with 3 argument(s).">pointer_functor3</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1pointer__functor3.html#adf560c1e583b2216bba4de3027e3a05e" title="Execute the wrapped function.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1pointer__functor3.html#adf560c1e583b2216bba4de3027e3a05e" title="Execute the wrapped function.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1pointer__functor3.html#adf560c1e583b2216bba4de3027e3a05e" title="Execute the wrapped function.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1pointer__functor3.html#adf560c1e583b2216bba4de3027e3a05e" title="Execute the wrapped function.">operator()()</a>. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a2a0ed29803c02cc62fcc6497f83f88bf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2a0ed29803c02cc62fcc6497f83f88bf">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1pointer__functor3.html">sigc::pointer_functor3</a>< T_arg1, T_arg2, T_arg3, T_return >::<a class="el" href="classsigc_1_1pointer__functor3.html#a2a0ed29803c02cc62fcc6497f83f88bf">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a1a4909d1444e4456a89eb5852933d1cc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1a4909d1444e4456a89eb5852933d1cc">◆ </a></span>pointer_functor3() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor3.html">sigc::pointer_functor3</a>< T_arg1, T_arg2, T_arg3, T_return >::<a class="el" href="classsigc_1_1pointer__functor3.html">pointer_functor3</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="aae48103ba1c48e192a04c9a1b81ae9dc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aae48103ba1c48e192a04c9a1b81ae9dc">◆ </a></span>pointer_functor3() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor3.html">sigc::pointer_functor3</a>< T_arg1, T_arg2, T_arg3, T_return >::<a class="el" href="classsigc_1_1pointer__functor3.html">pointer_functor3</a> </td>
+ <td>(</td>
+ <td class="paramtype">function_type </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1pointer__functor3.html" title="pointer_functor3 wraps existing non-member functions with 3 argument(s).">pointer_functor3</a> object that wraps an existing function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to function that will be invoked from <a class="el" href="classsigc_1_1pointer__functor3.html#adf560c1e583b2216bba4de3027e3a05e" title="Execute the wrapped function.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="adf560c1e583b2216bba4de3027e3a05e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#adf560c1e583b2216bba4de3027e3a05e">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1pointer__functor3.html">sigc::pointer_functor3</a>< T_arg1, T_arg2, T_arg3, T_return >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the function. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the function. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the function. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the function invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a1ac1e43f2515d64c0da4656cdfac1f44"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1ac1e43f2515d64c0da4656cdfac1f44">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">function_type <a class="el" href="classsigc_1_1pointer__functor3.html">sigc::pointer_functor3</a>< T_arg1, T_arg2, T_arg3, T_return >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::pointer_functor3< T_arg1, T_arg2, T_arg3, T_return >" name="sigc::pointer_functor3< T_arg1, T_arg2, T_arg3, T_return >">
+<area shape="rect" id="node1" title="pointer_functor3 wraps existing non-member functions with 3 argument(s)." alt="" coords="5,80,195,136"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="30,5,170,32"/>
+</map>
--- /dev/null
+e24e77c1f2772ce2f8675b7391bae92a
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1pointer__functor4.html">pointer_functor4</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1pointer__functor4.html">sigc::pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1pointer__functor4.html#af7079533ac64ac9ba23eab99e5c54269">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor4.html">sigc::pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1pointer__functor4.html#a42875d789a30fb04395dbef76d720989">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor4.html">sigc::pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1pointer__functor4.html#ab8e3bf143e71c5ffe8f155ace0f895a8">pointer_functor4</a>()</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor4.html">sigc::pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1pointer__functor4.html#a30eaeb5f9974bed73d7577b862c2e06b">pointer_functor4</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor4.html">sigc::pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1pointer__functor4.html#a787f8ea1c15d7bfab7643081a408401c">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor4.html">sigc::pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1pointer__functor4.html">pointer_functor4</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1pointer__functor4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__ptr__fun.html">ptr_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1pointer__functor4.html" title="pointer_functor4 wraps existing non-member functions with 4 argument(s).">pointer_functor4</a> wraps existing non-member functions with 4 argument(s).
+ <a href="classsigc_1_1pointer__functor4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/ptr_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1pointer__functor4__inherit__graph.png" border="0" usemap="#asigc_1_1pointer__functor4_3_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__return_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1pointer__functor4_3_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__return_01_4_inherit__map" id="asigc_1_1pointer__functor4_3_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__return_01_4_inherit__map">
+<area shape="rect" title="pointer_functor4 wraps existing non-member functions with 4 argument(s)." alt="" coords="5,80,195,136"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="30,5,170,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a787f8ea1c15d7bfab7643081a408401c"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor4.html#a787f8ea1c15d7bfab7643081a408401c">result_type</a></td></tr>
+<tr class="separator:a787f8ea1c15d7bfab7643081a408401c"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:ab8e3bf143e71c5ffe8f155ace0f895a8"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor4.html#ab8e3bf143e71c5ffe8f155ace0f895a8">pointer_functor4</a> ()</td></tr>
+<tr class="memdesc:ab8e3bf143e71c5ffe8f155ace0f895a8"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1pointer__functor4.html#ab8e3bf143e71c5ffe8f155ace0f895a8">More...</a><br /></td></tr>
+<tr class="separator:ab8e3bf143e71c5ffe8f155ace0f895a8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a30eaeb5f9974bed73d7577b862c2e06b"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor4.html#a30eaeb5f9974bed73d7577b862c2e06b">pointer_functor4</a> (function_type _A_func)</td></tr>
+<tr class="memdesc:a30eaeb5f9974bed73d7577b862c2e06b"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1pointer__functor4.html" title="pointer_functor4 wraps existing non-member functions with 4 argument(s).">pointer_functor4</a> object that wraps an existing function. <a href="classsigc_1_1pointer__functor4.html#a30eaeb5f9974bed73d7577b862c2e06b">More...</a><br /></td></tr>
+<tr class="separator:a30eaeb5f9974bed73d7577b862c2e06b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a42875d789a30fb04395dbef76d720989"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor4.html#a42875d789a30fb04395dbef76d720989">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:a42875d789a30fb04395dbef76d720989"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped function. <a href="classsigc_1_1pointer__functor4.html#a42875d789a30fb04395dbef76d720989">More...</a><br /></td></tr>
+<tr class="separator:a42875d789a30fb04395dbef76d720989"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:af7079533ac64ac9ba23eab99e5c54269"><td class="memItemLeft" align="right" valign="top">function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor4.html#af7079533ac64ac9ba23eab99e5c54269">func_ptr_</a></td></tr>
+<tr class="separator:af7079533ac64ac9ba23eab99e5c54269"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return><br />
+class sigc::pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return ></h3>
+
+<p><a class="el" href="classsigc_1_1pointer__functor4.html" title="pointer_functor4 wraps existing non-member functions with 4 argument(s).">pointer_functor4</a> wraps existing non-member functions with 4 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863" title="Creates a functor of type sigc::pointer_functor0 which wraps an existing non-member function.">ptr_fun()</a> to create an instance of <a class="el" href="classsigc_1_1pointer__functor4.html" title="pointer_functor4 wraps existing non-member functions with 4 argument(s).">pointer_functor4</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1pointer__functor4.html#a42875d789a30fb04395dbef76d720989" title="Execute the wrapped function.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1pointer__functor4.html#a42875d789a30fb04395dbef76d720989" title="Execute the wrapped function.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1pointer__functor4.html#a42875d789a30fb04395dbef76d720989" title="Execute the wrapped function.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1pointer__functor4.html#a42875d789a30fb04395dbef76d720989" title="Execute the wrapped function.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1pointer__functor4.html#a42875d789a30fb04395dbef76d720989" title="Execute the wrapped function.">operator()()</a>. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a787f8ea1c15d7bfab7643081a408401c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a787f8ea1c15d7bfab7643081a408401c">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1pointer__functor4.html">sigc::pointer_functor4</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_return >::<a class="el" href="classsigc_1_1pointer__functor4.html#a787f8ea1c15d7bfab7643081a408401c">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="ab8e3bf143e71c5ffe8f155ace0f895a8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab8e3bf143e71c5ffe8f155ace0f895a8">◆ </a></span>pointer_functor4() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor4.html">sigc::pointer_functor4</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_return >::<a class="el" href="classsigc_1_1pointer__functor4.html">pointer_functor4</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="a30eaeb5f9974bed73d7577b862c2e06b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a30eaeb5f9974bed73d7577b862c2e06b">◆ </a></span>pointer_functor4() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor4.html">sigc::pointer_functor4</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_return >::<a class="el" href="classsigc_1_1pointer__functor4.html">pointer_functor4</a> </td>
+ <td>(</td>
+ <td class="paramtype">function_type </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1pointer__functor4.html" title="pointer_functor4 wraps existing non-member functions with 4 argument(s).">pointer_functor4</a> object that wraps an existing function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to function that will be invoked from <a class="el" href="classsigc_1_1pointer__functor4.html#a42875d789a30fb04395dbef76d720989" title="Execute the wrapped function.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a42875d789a30fb04395dbef76d720989"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a42875d789a30fb04395dbef76d720989">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1pointer__functor4.html">sigc::pointer_functor4</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_return >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the function. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the function. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the function. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the function. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the function invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="af7079533ac64ac9ba23eab99e5c54269"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af7079533ac64ac9ba23eab99e5c54269">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">function_type <a class="el" href="classsigc_1_1pointer__functor4.html">sigc::pointer_functor4</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_return >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return >" name="sigc::pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return >">
+<area shape="rect" id="node1" title="pointer_functor4 wraps existing non-member functions with 4 argument(s)." alt="" coords="5,80,195,136"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="30,5,170,32"/>
+</map>
--- /dev/null
+5edc0bd2d293127f652b07de7766b739
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1pointer__functor5.html">pointer_functor5</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1pointer__functor5.html">sigc::pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1pointer__functor5.html#a1c97e4e7e8598e06802b07cb86b32466">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor5.html">sigc::pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1pointer__functor5.html#aa2f399d3f76e802670c8a08ede82c40c">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor5.html">sigc::pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1pointer__functor5.html#aa86bb74ff5e188f8f6497b7e73621cdd">pointer_functor5</a>()</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor5.html">sigc::pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1pointer__functor5.html#abf1e06db145e4554ec53964ca79171cf">pointer_functor5</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor5.html">sigc::pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1pointer__functor5.html#a00dcbec8a920ea784e3210743c77855b">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor5.html">sigc::pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1pointer__functor5.html">pointer_functor5</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1pointer__functor5-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__ptr__fun.html">ptr_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1pointer__functor5.html" title="pointer_functor5 wraps existing non-member functions with 5 argument(s).">pointer_functor5</a> wraps existing non-member functions with 5 argument(s).
+ <a href="classsigc_1_1pointer__functor5.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/ptr_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1pointer__functor5__inherit__graph.png" border="0" usemap="#asigc_1_1pointer__functor5_3_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__return_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1pointer__functor5_3_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__return_01_4_inherit__map" id="asigc_1_1pointer__functor5_3_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__return_01_4_inherit__map">
+<area shape="rect" title="pointer_functor5 wraps existing non-member functions with 5 argument(s)." alt="" coords="5,80,204,136"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="35,5,175,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a00dcbec8a920ea784e3210743c77855b"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor5.html#a00dcbec8a920ea784e3210743c77855b">result_type</a></td></tr>
+<tr class="separator:a00dcbec8a920ea784e3210743c77855b"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:aa86bb74ff5e188f8f6497b7e73621cdd"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor5.html#aa86bb74ff5e188f8f6497b7e73621cdd">pointer_functor5</a> ()</td></tr>
+<tr class="memdesc:aa86bb74ff5e188f8f6497b7e73621cdd"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1pointer__functor5.html#aa86bb74ff5e188f8f6497b7e73621cdd">More...</a><br /></td></tr>
+<tr class="separator:aa86bb74ff5e188f8f6497b7e73621cdd"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abf1e06db145e4554ec53964ca79171cf"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor5.html#abf1e06db145e4554ec53964ca79171cf">pointer_functor5</a> (function_type _A_func)</td></tr>
+<tr class="memdesc:abf1e06db145e4554ec53964ca79171cf"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1pointer__functor5.html" title="pointer_functor5 wraps existing non-member functions with 5 argument(s).">pointer_functor5</a> object that wraps an existing function. <a href="classsigc_1_1pointer__functor5.html#abf1e06db145e4554ec53964ca79171cf">More...</a><br /></td></tr>
+<tr class="separator:abf1e06db145e4554ec53964ca79171cf"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa2f399d3f76e802670c8a08ede82c40c"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor5.html#aa2f399d3f76e802670c8a08ede82c40c">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:aa2f399d3f76e802670c8a08ede82c40c"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped function. <a href="classsigc_1_1pointer__functor5.html#aa2f399d3f76e802670c8a08ede82c40c">More...</a><br /></td></tr>
+<tr class="separator:aa2f399d3f76e802670c8a08ede82c40c"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:a1c97e4e7e8598e06802b07cb86b32466"><td class="memItemLeft" align="right" valign="top">function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor5.html#a1c97e4e7e8598e06802b07cb86b32466">func_ptr_</a></td></tr>
+<tr class="separator:a1c97e4e7e8598e06802b07cb86b32466"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return><br />
+class sigc::pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return ></h3>
+
+<p><a class="el" href="classsigc_1_1pointer__functor5.html" title="pointer_functor5 wraps existing non-member functions with 5 argument(s).">pointer_functor5</a> wraps existing non-member functions with 5 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863" title="Creates a functor of type sigc::pointer_functor0 which wraps an existing non-member function.">ptr_fun()</a> to create an instance of <a class="el" href="classsigc_1_1pointer__functor5.html" title="pointer_functor5 wraps existing non-member functions with 5 argument(s).">pointer_functor5</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1pointer__functor5.html#aa2f399d3f76e802670c8a08ede82c40c" title="Execute the wrapped function.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1pointer__functor5.html#aa2f399d3f76e802670c8a08ede82c40c" title="Execute the wrapped function.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1pointer__functor5.html#aa2f399d3f76e802670c8a08ede82c40c" title="Execute the wrapped function.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1pointer__functor5.html#aa2f399d3f76e802670c8a08ede82c40c" title="Execute the wrapped function.">operator()()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1pointer__functor5.html#aa2f399d3f76e802670c8a08ede82c40c" title="Execute the wrapped function.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1pointer__functor5.html#aa2f399d3f76e802670c8a08ede82c40c" title="Execute the wrapped function.">operator()()</a>. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a00dcbec8a920ea784e3210743c77855b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a00dcbec8a920ea784e3210743c77855b">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1pointer__functor5.html">sigc::pointer_functor5</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return >::<a class="el" href="classsigc_1_1pointer__functor5.html#a00dcbec8a920ea784e3210743c77855b">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="aa86bb74ff5e188f8f6497b7e73621cdd"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa86bb74ff5e188f8f6497b7e73621cdd">◆ </a></span>pointer_functor5() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor5.html">sigc::pointer_functor5</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return >::<a class="el" href="classsigc_1_1pointer__functor5.html">pointer_functor5</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="abf1e06db145e4554ec53964ca79171cf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abf1e06db145e4554ec53964ca79171cf">◆ </a></span>pointer_functor5() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor5.html">sigc::pointer_functor5</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return >::<a class="el" href="classsigc_1_1pointer__functor5.html">pointer_functor5</a> </td>
+ <td>(</td>
+ <td class="paramtype">function_type </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1pointer__functor5.html" title="pointer_functor5 wraps existing non-member functions with 5 argument(s).">pointer_functor5</a> object that wraps an existing function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to function that will be invoked from <a class="el" href="classsigc_1_1pointer__functor5.html#aa2f399d3f76e802670c8a08ede82c40c" title="Execute the wrapped function.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="aa2f399d3f76e802670c8a08ede82c40c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa2f399d3f76e802670c8a08ede82c40c">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1pointer__functor5.html">sigc::pointer_functor5</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the function. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the function. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the function. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the function. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the function. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the function invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a1c97e4e7e8598e06802b07cb86b32466"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1c97e4e7e8598e06802b07cb86b32466">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">function_type <a class="el" href="classsigc_1_1pointer__functor5.html">sigc::pointer_functor5</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return >" name="sigc::pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return >">
+<area shape="rect" id="node1" title="pointer_functor5 wraps existing non-member functions with 5 argument(s)." alt="" coords="5,80,204,136"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="35,5,175,32"/>
+</map>
--- /dev/null
+2629c27777565319b3d61065c74932ec
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1pointer__functor6.html">pointer_functor6</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1pointer__functor6.html">sigc::pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1pointer__functor6.html#a69c965009b6c3b65106c731b20e60368">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor6.html">sigc::pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1pointer__functor6.html#ac35109048b7360e1436e2b4e3a53d1cf">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor6.html">sigc::pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1pointer__functor6.html#a26551fa703a65a9a14190c7579a3b77d">pointer_functor6</a>()</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor6.html">sigc::pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1pointer__functor6.html#ab56acb7713cf87d0b3094adc4ffe7a15">pointer_functor6</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor6.html">sigc::pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1pointer__functor6.html#a9fd7af745ebad4d59f67e0f60fb395e0">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor6.html">sigc::pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1pointer__functor6.html">pointer_functor6</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1pointer__functor6-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__ptr__fun.html">ptr_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1pointer__functor6.html" title="pointer_functor6 wraps existing non-member functions with 6 argument(s).">pointer_functor6</a> wraps existing non-member functions with 6 argument(s).
+ <a href="classsigc_1_1pointer__functor6.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/ptr_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1pointer__functor6__inherit__graph.png" border="0" usemap="#asigc_1_1pointer__functor6_3_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__return_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1pointer__functor6_3_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__return_01_4_inherit__map" id="asigc_1_1pointer__functor6_3_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__return_01_4_inherit__map">
+<area shape="rect" title="pointer_functor6 wraps existing non-member functions with 6 argument(s)." alt="" coords="5,80,195,151"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="30,5,170,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a9fd7af745ebad4d59f67e0f60fb395e0"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor6.html#a9fd7af745ebad4d59f67e0f60fb395e0">result_type</a></td></tr>
+<tr class="separator:a9fd7af745ebad4d59f67e0f60fb395e0"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a26551fa703a65a9a14190c7579a3b77d"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor6.html#a26551fa703a65a9a14190c7579a3b77d">pointer_functor6</a> ()</td></tr>
+<tr class="memdesc:a26551fa703a65a9a14190c7579a3b77d"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1pointer__functor6.html#a26551fa703a65a9a14190c7579a3b77d">More...</a><br /></td></tr>
+<tr class="separator:a26551fa703a65a9a14190c7579a3b77d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab56acb7713cf87d0b3094adc4ffe7a15"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor6.html#ab56acb7713cf87d0b3094adc4ffe7a15">pointer_functor6</a> (function_type _A_func)</td></tr>
+<tr class="memdesc:ab56acb7713cf87d0b3094adc4ffe7a15"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1pointer__functor6.html" title="pointer_functor6 wraps existing non-member functions with 6 argument(s).">pointer_functor6</a> object that wraps an existing function. <a href="classsigc_1_1pointer__functor6.html#ab56acb7713cf87d0b3094adc4ffe7a15">More...</a><br /></td></tr>
+<tr class="separator:ab56acb7713cf87d0b3094adc4ffe7a15"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac35109048b7360e1436e2b4e3a53d1cf"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor6.html#ac35109048b7360e1436e2b4e3a53d1cf">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:ac35109048b7360e1436e2b4e3a53d1cf"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped function. <a href="classsigc_1_1pointer__functor6.html#ac35109048b7360e1436e2b4e3a53d1cf">More...</a><br /></td></tr>
+<tr class="separator:ac35109048b7360e1436e2b4e3a53d1cf"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:a69c965009b6c3b65106c731b20e60368"><td class="memItemLeft" align="right" valign="top">function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor6.html#a69c965009b6c3b65106c731b20e60368">func_ptr_</a></td></tr>
+<tr class="separator:a69c965009b6c3b65106c731b20e60368"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return><br />
+class sigc::pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return ></h3>
+
+<p><a class="el" href="classsigc_1_1pointer__functor6.html" title="pointer_functor6 wraps existing non-member functions with 6 argument(s).">pointer_functor6</a> wraps existing non-member functions with 6 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863" title="Creates a functor of type sigc::pointer_functor0 which wraps an existing non-member function.">ptr_fun()</a> to create an instance of <a class="el" href="classsigc_1_1pointer__functor6.html" title="pointer_functor6 wraps existing non-member functions with 6 argument(s).">pointer_functor6</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1pointer__functor6.html#ac35109048b7360e1436e2b4e3a53d1cf" title="Execute the wrapped function.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1pointer__functor6.html#ac35109048b7360e1436e2b4e3a53d1cf" title="Execute the wrapped function.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1pointer__functor6.html#ac35109048b7360e1436e2b4e3a53d1cf" title="Execute the wrapped function.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1pointer__functor6.html#ac35109048b7360e1436e2b4e3a53d1cf" title="Execute the wrapped function.">operator()()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1pointer__functor6.html#ac35109048b7360e1436e2b4e3a53d1cf" title="Execute the wrapped function.">operator()()</a>.</li>
+<li><em>T_arg6</em> Argument type used in the definition of <a class="el" href="classsigc_1_1pointer__functor6.html#ac35109048b7360e1436e2b4e3a53d1cf" title="Execute the wrapped function.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1pointer__functor6.html#ac35109048b7360e1436e2b4e3a53d1cf" title="Execute the wrapped function.">operator()()</a>. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a9fd7af745ebad4d59f67e0f60fb395e0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9fd7af745ebad4d59f67e0f60fb395e0">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1pointer__functor6.html">sigc::pointer_functor6</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return >::<a class="el" href="classsigc_1_1pointer__functor6.html#a9fd7af745ebad4d59f67e0f60fb395e0">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a26551fa703a65a9a14190c7579a3b77d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a26551fa703a65a9a14190c7579a3b77d">◆ </a></span>pointer_functor6() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor6.html">sigc::pointer_functor6</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return >::<a class="el" href="classsigc_1_1pointer__functor6.html">pointer_functor6</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="ab56acb7713cf87d0b3094adc4ffe7a15"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab56acb7713cf87d0b3094adc4ffe7a15">◆ </a></span>pointer_functor6() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor6.html">sigc::pointer_functor6</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return >::<a class="el" href="classsigc_1_1pointer__functor6.html">pointer_functor6</a> </td>
+ <td>(</td>
+ <td class="paramtype">function_type </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1pointer__functor6.html" title="pointer_functor6 wraps existing non-member functions with 6 argument(s).">pointer_functor6</a> object that wraps an existing function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to function that will be invoked from <a class="el" href="classsigc_1_1pointer__functor6.html#ac35109048b7360e1436e2b4e3a53d1cf" title="Execute the wrapped function.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="ac35109048b7360e1436e2b4e3a53d1cf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac35109048b7360e1436e2b4e3a53d1cf">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1pointer__functor6.html">sigc::pointer_functor6</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the function. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the function. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the function. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the function. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the function. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the function. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the function invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a69c965009b6c3b65106c731b20e60368"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a69c965009b6c3b65106c731b20e60368">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">function_type <a class="el" href="classsigc_1_1pointer__functor6.html">sigc::pointer_functor6</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return >" name="sigc::pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return >">
+<area shape="rect" id="node1" title="pointer_functor6 wraps existing non-member functions with 6 argument(s)." alt="" coords="5,80,195,151"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="30,5,170,32"/>
+</map>
--- /dev/null
+f398c9d08d94657dcdc96af7167aae23
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1pointer__functor7.html">pointer_functor7</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1pointer__functor7.html">sigc::pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1pointer__functor7.html#aa092fb6515cb3496529b253b1a57118b">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor7.html">sigc::pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1pointer__functor7.html#a564941861ee4b84b9b61a1f247f0cfa1">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor7.html">sigc::pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1pointer__functor7.html#a1268abfa3437c0977517dd4cd0548080">pointer_functor7</a>()</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor7.html">sigc::pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1pointer__functor7.html#a01a6793cd057cd94bba98db3b34a3e7c">pointer_functor7</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor7.html">sigc::pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1pointer__functor7.html#a41613e64e2b96656b85aa9eefa35aa91">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1pointer__functor7.html">sigc::pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1pointer__functor7.html">pointer_functor7</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1pointer__functor7-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__ptr__fun.html">ptr_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1pointer__functor7.html" title="pointer_functor7 wraps existing non-member functions with 7 argument(s).">pointer_functor7</a> wraps existing non-member functions with 7 argument(s).
+ <a href="classsigc_1_1pointer__functor7.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/ptr_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1pointer__functor7__inherit__graph.png" border="0" usemap="#asigc_1_1pointer__functor7_3_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_00_01T__return_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1pointer__functor7_3_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_00_01T__return_01_4_inherit__map" id="asigc_1_1pointer__functor7_3_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_00_01T__return_01_4_inherit__map">
+<area shape="rect" title="pointer_functor7 wraps existing non-member functions with 7 argument(s)." alt="" coords="5,80,195,151"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="30,5,170,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a41613e64e2b96656b85aa9eefa35aa91"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor7.html#a41613e64e2b96656b85aa9eefa35aa91">result_type</a></td></tr>
+<tr class="separator:a41613e64e2b96656b85aa9eefa35aa91"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a1268abfa3437c0977517dd4cd0548080"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor7.html#a1268abfa3437c0977517dd4cd0548080">pointer_functor7</a> ()</td></tr>
+<tr class="memdesc:a1268abfa3437c0977517dd4cd0548080"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1pointer__functor7.html#a1268abfa3437c0977517dd4cd0548080">More...</a><br /></td></tr>
+<tr class="separator:a1268abfa3437c0977517dd4cd0548080"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a01a6793cd057cd94bba98db3b34a3e7c"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor7.html#a01a6793cd057cd94bba98db3b34a3e7c">pointer_functor7</a> (function_type _A_func)</td></tr>
+<tr class="memdesc:a01a6793cd057cd94bba98db3b34a3e7c"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1pointer__functor7.html" title="pointer_functor7 wraps existing non-member functions with 7 argument(s).">pointer_functor7</a> object that wraps an existing function. <a href="classsigc_1_1pointer__functor7.html#a01a6793cd057cd94bba98db3b34a3e7c">More...</a><br /></td></tr>
+<tr class="separator:a01a6793cd057cd94bba98db3b34a3e7c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a564941861ee4b84b9b61a1f247f0cfa1"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor7.html#a564941861ee4b84b9b61a1f247f0cfa1">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:a564941861ee4b84b9b61a1f247f0cfa1"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped function. <a href="classsigc_1_1pointer__functor7.html#a564941861ee4b84b9b61a1f247f0cfa1">More...</a><br /></td></tr>
+<tr class="separator:a564941861ee4b84b9b61a1f247f0cfa1"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:aa092fb6515cb3496529b253b1a57118b"><td class="memItemLeft" align="right" valign="top">function_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor7.html#aa092fb6515cb3496529b253b1a57118b">func_ptr_</a></td></tr>
+<tr class="separator:aa092fb6515cb3496529b253b1a57118b"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return><br />
+class sigc::pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return ></h3>
+
+<p><a class="el" href="classsigc_1_1pointer__functor7.html" title="pointer_functor7 wraps existing non-member functions with 7 argument(s).">pointer_functor7</a> wraps existing non-member functions with 7 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863" title="Creates a functor of type sigc::pointer_functor0 which wraps an existing non-member function.">ptr_fun()</a> to create an instance of <a class="el" href="classsigc_1_1pointer__functor7.html" title="pointer_functor7 wraps existing non-member functions with 7 argument(s).">pointer_functor7</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1pointer__functor7.html#a564941861ee4b84b9b61a1f247f0cfa1" title="Execute the wrapped function.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1pointer__functor7.html#a564941861ee4b84b9b61a1f247f0cfa1" title="Execute the wrapped function.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1pointer__functor7.html#a564941861ee4b84b9b61a1f247f0cfa1" title="Execute the wrapped function.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1pointer__functor7.html#a564941861ee4b84b9b61a1f247f0cfa1" title="Execute the wrapped function.">operator()()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1pointer__functor7.html#a564941861ee4b84b9b61a1f247f0cfa1" title="Execute the wrapped function.">operator()()</a>.</li>
+<li><em>T_arg6</em> Argument type used in the definition of <a class="el" href="classsigc_1_1pointer__functor7.html#a564941861ee4b84b9b61a1f247f0cfa1" title="Execute the wrapped function.">operator()()</a>.</li>
+<li><em>T_arg7</em> Argument type used in the definition of <a class="el" href="classsigc_1_1pointer__functor7.html#a564941861ee4b84b9b61a1f247f0cfa1" title="Execute the wrapped function.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1pointer__functor7.html#a564941861ee4b84b9b61a1f247f0cfa1" title="Execute the wrapped function.">operator()()</a>. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a41613e64e2b96656b85aa9eefa35aa91"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a41613e64e2b96656b85aa9eefa35aa91">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1pointer__functor7.html">sigc::pointer_functor7</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return >::<a class="el" href="classsigc_1_1pointer__functor7.html#a41613e64e2b96656b85aa9eefa35aa91">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a1268abfa3437c0977517dd4cd0548080"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1268abfa3437c0977517dd4cd0548080">◆ </a></span>pointer_functor7() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor7.html">sigc::pointer_functor7</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return >::<a class="el" href="classsigc_1_1pointer__functor7.html">pointer_functor7</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="a01a6793cd057cd94bba98db3b34a3e7c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a01a6793cd057cd94bba98db3b34a3e7c">◆ </a></span>pointer_functor7() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor7.html">sigc::pointer_functor7</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return >::<a class="el" href="classsigc_1_1pointer__functor7.html">pointer_functor7</a> </td>
+ <td>(</td>
+ <td class="paramtype">function_type </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1pointer__functor7.html" title="pointer_functor7 wraps existing non-member functions with 7 argument(s).">pointer_functor7</a> object that wraps an existing function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to function that will be invoked from <a class="el" href="classsigc_1_1pointer__functor7.html#a564941861ee4b84b9b61a1f247f0cfa1" title="Execute the wrapped function.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a564941861ee4b84b9b61a1f247f0cfa1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a564941861ee4b84b9b61a1f247f0cfa1">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1pointer__functor7.html">sigc::pointer_functor7</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > </td>
+ <td class="paramname"><em>_A_a7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the function. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the function. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the function. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the function. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the function. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the function. </td></tr>
+ <tr><td class="paramname">_A_a7</td><td>Argument to be passed on to the function. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the function invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="aa092fb6515cb3496529b253b1a57118b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa092fb6515cb3496529b253b1a57118b">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">function_type <a class="el" href="classsigc_1_1pointer__functor7.html">sigc::pointer_functor7</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return >" name="sigc::pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return >">
+<area shape="rect" id="node1" title="pointer_functor7 wraps existing non-member functions with 7 argument(s)." alt="" coords="5,80,195,151"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="30,5,170,32"/>
+</map>
--- /dev/null
+3c233d713027917e137283eb1b739e7d
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal.html">signal</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a5aed4bdb8d85c3d854f01410d2d9d3a4">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a6eef6225eba66a86dd32c3f3b79845f7">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#ad1ba32ad7dae0c05a4012ada78077505">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2">emit</a>(type_trait_take_t< nil > _A_a1, type_trait_take_t< nil > _A_a2, type_trait_take_t< nil > _A_a3, type_trait_take_t< nil > _A_a4, type_trait_take_t< nil > _A_a5, type_trait_take_t< nil > _A_a6, type_trait_take_t< nil > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a192581feb2dbcfc9c56692e72e91e9a8">emit_reverse</a>(type_trait_take_t< nil > _A_a1, type_trait_take_t< nil > _A_a2, type_trait_take_t< nil > _A_a3, type_trait_take_t< nil > _A_a4, type_trait_take_t< nil > _A_a5, type_trait_take_t< nil > _A_a6, type_trait_take_t< nil > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a7fa856e67a31c86538db7c289a6870e3">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a3f468c8b6cc55d675c75d0184bd8e38a">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#ac6fd43215c8f19082402387359330071">operator()</a>(type_trait_take_t< nil > _A_a1, type_trait_take_t< nil > _A_a2, type_trait_take_t< nil > _A_a3, type_trait_take_t< nil > _A_a4, type_trait_take_t< nil > _A_a5, type_trait_take_t< nil > _A_a6, type_trait_take_t< nil > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal.html#adeccc0c1c698e33c1da15c7f667f2a23">operator=</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal.html#abca2c029617e5b39f2852ee0381e7f9e">operator=</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#af8a93a4c8fb0b78fa6578e7dc95f5751">signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil >::operator=</a>(const signal7 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#ac06938f5cb6ff60a1bd5eaa32c990eea">signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil >::operator=</a>(signal7 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a59c9c9fee7a98528839df592241351a9">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal.html#a50432d1aebfbee5ef17a3f434d0c50bf">signal</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal.html#a271b486daa2bf801ed7d019da9aa33a1">signal</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal.html#abc17a093db8ae8a0a8333c7f35f64bd6">signal</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#ab6d54db53a164fb459fcb342d4b45ff0">signal7</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a12d6e064d0a5c2a8c09d60a64184a823">signal7</a>(const signal7 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a5a5893dd4f97d77b7945819f5ada2aee">signal7</a>(signal7 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a68153d9079b4881352113079cd6216f7">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a42509108239296e424844df2cd330aca">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal.html">signal</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#nested-classes">Classes</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Class Template Reference<div class="ingroups"><a class="el" href="group__signal.html">Signals</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates.
+ <a href="classsigc_1_1signal.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal__inherit__graph.png" border="0" usemap="#asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map" id="asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::signal# templates." alt="" coords="5,259,184,329"/>
+<area shape="rect" href="classsigc_1_1signal7.html" title=" " alt="" coords="7,155,183,211"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="28,80,161,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="37,5,153,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Classes</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_1_1accumulated.html">accumulated</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates. <a href="classsigc_1_1signal_1_1accumulated.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a50432d1aebfbee5ef17a3f434d0c50bf"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal.html#a50432d1aebfbee5ef17a3f434d0c50bf">signal</a> ()</td></tr>
+<tr class="separator:a50432d1aebfbee5ef17a3f434d0c50bf"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a271b486daa2bf801ed7d019da9aa33a1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal.html#a271b486daa2bf801ed7d019da9aa33a1">signal</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:a271b486daa2bf801ed7d019da9aa33a1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abc17a093db8ae8a0a8333c7f35f64bd6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal.html#abc17a093db8ae8a0a8333c7f35f64bd6">signal</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:abc17a093db8ae8a0a8333c7f35f64bd6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adeccc0c1c698e33c1da15c7f667f2a23"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal.html#adeccc0c1c698e33c1da15c7f667f2a23">operator=</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:adeccc0c1c698e33c1da15c7f667f2a23"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abca2c029617e5b39f2852ee0381e7f9e"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal.html#abca2c029617e5b39f2852ee0381e7f9e">operator=</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:abca2c029617e5b39f2852ee0381e7f9e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal7"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal7')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil ></a></td></tr>
+<tr class="memitem:ab6d54db53a164fb459fcb342d4b45ff0 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#ab6d54db53a164fb459fcb342d4b45ff0">signal7</a> ()</td></tr>
+<tr class="separator:ab6d54db53a164fb459fcb342d4b45ff0 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a12d6e064d0a5c2a8c09d60a64184a823 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a12d6e064d0a5c2a8c09d60a64184a823">signal7</a> (const <a class="el" href="classsigc_1_1signal7.html">signal7</a> & src)</td></tr>
+<tr class="separator:a12d6e064d0a5c2a8c09d60a64184a823 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5a5893dd4f97d77b7945819f5ada2aee inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a5a5893dd4f97d77b7945819f5ada2aee">signal7</a> (<a class="el" href="classsigc_1_1signal7.html">signal7</a> && src)</td></tr>
+<tr class="separator:a5a5893dd4f97d77b7945819f5ada2aee inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adc55ac9b0f935fd87a67904022e03cb2 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">connect</a> (const <a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:adc55ac9b0f935fd87a67904022e03cb2 inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">More...</a><br /></td></tr>
+<tr class="separator:adc55ac9b0f935fd87a67904022e03cb2 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5aed4bdb8d85c3d854f01410d2d9d3a4 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a5aed4bdb8d85c3d854f01410d2d9d3a4">connect</a> (<a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:a5aed4bdb8d85c3d854f01410d2d9d3a4 inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal7.html#a5aed4bdb8d85c3d854f01410d2d9d3a4">More...</a><br /></td></tr>
+<tr class="separator:a5aed4bdb8d85c3d854f01410d2d9d3a4 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aead3b0e97ed0bd95f870b1956bff83c2 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > _A_a7) const</td></tr>
+<tr class="memdesc:aead3b0e97ed0bd95f870b1956bff83c2 inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2">More...</a><br /></td></tr>
+<tr class="separator:aead3b0e97ed0bd95f870b1956bff83c2 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a192581feb2dbcfc9c56692e72e91e9a8 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a192581feb2dbcfc9c56692e72e91e9a8">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > _A_a7) const</td></tr>
+<tr class="memdesc:a192581feb2dbcfc9c56692e72e91e9a8 inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal7.html#a192581feb2dbcfc9c56692e72e91e9a8">More...</a><br /></td></tr>
+<tr class="separator:a192581feb2dbcfc9c56692e72e91e9a8 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3f468c8b6cc55d675c75d0184bd8e38a inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html">bound_const_mem_functor7</a>< <a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a>, <a class="el" href="classsigc_1_1signal7.html">signal7</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a3f468c8b6cc55d675c75d0184bd8e38a">make_slot</a> () const</td></tr>
+<tr class="memdesc:a3f468c8b6cc55d675c75d0184bd8e38a inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal7.html#a3f468c8b6cc55d675c75d0184bd8e38a">More...</a><br /></td></tr>
+<tr class="separator:a3f468c8b6cc55d675c75d0184bd8e38a inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac6fd43215c8f19082402387359330071 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#ac6fd43215c8f19082402387359330071">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > _A_a7) const</td></tr>
+<tr class="memdesc:ac6fd43215c8f19082402387359330071 inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal7.html#ac6fd43215c8f19082402387359330071">More...</a><br /></td></tr>
+<tr class="separator:ac6fd43215c8f19082402387359330071 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af8a93a4c8fb0b78fa6578e7dc95f5751 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html">signal7</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#af8a93a4c8fb0b78fa6578e7dc95f5751">operator=</a> (const <a class="el" href="classsigc_1_1signal7.html">signal7</a> & src)</td></tr>
+<tr class="separator:af8a93a4c8fb0b78fa6578e7dc95f5751 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac06938f5cb6ff60a1bd5eaa32c990eea inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html">signal7</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#ac06938f5cb6ff60a1bd5eaa32c990eea">operator=</a> (<a class="el" href="classsigc_1_1signal7.html">signal7</a> && src)</td></tr>
+<tr class="separator:ac06938f5cb6ff60a1bd5eaa32c990eea inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a68153d9079b4881352113079cd6216f7 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a68153d9079b4881352113079cd6216f7">slots</a> ()</td></tr>
+<tr class="memdesc:a68153d9079b4881352113079cd6216f7 inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal7.html#a68153d9079b4881352113079cd6216f7">More...</a><br /></td></tr>
+<tr class="separator:a68153d9079b4881352113079cd6216f7 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a42509108239296e424844df2cd330aca inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a42509108239296e424844df2cd330aca">slots</a> () const</td></tr>
+<tr class="memdesc:a42509108239296e424844df2cd330aca inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal7.html#a42509108239296e424844df2cd330aca">More...</a><br /></td></tr>
+<tr class="separator:a42509108239296e424844df2cd330aca inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal7"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal7')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil ></a></td></tr>
+<tr class="memitem:a6eef6225eba66a86dd32c3f3b79845f7 inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a6eef6225eba66a86dd32c3f3b79845f7">const_iterator</a></td></tr>
+<tr class="separator:a6eef6225eba66a86dd32c3f3b79845f7 inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1ba32ad7dae0c05a4012ada78077505 inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#ad1ba32ad7dae0c05a4012ada78077505">const_reverse_iterator</a></td></tr>
+<tr class="separator:ad1ba32ad7dae0c05a4012ada78077505 inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7fa856e67a31c86538db7c289a6870e3 inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit7< T_return, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a7fa856e67a31c86538db7c289a6870e3">emitter_type</a></td></tr>
+<tr class="separator:a7fa856e67a31c86538db7c289a6870e3 inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abc62e52cc684f917577a2fe3cd914d4a inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a">iterator</a></td></tr>
+<tr class="separator:abc62e52cc684f917577a2fe3cd914d4a inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5a75d73a254cf91a0f3ad1cd3545e29f inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a></td></tr>
+<tr class="separator:a5a75d73a254cf91a0f3ad1cd3545e29f inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a59c9c9fee7a98528839df592241351a9 inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a59c9c9fee7a98528839df592241351a9">reverse_iterator</a></td></tr>
+<tr class="separator:a59c9c9fee7a98528839df592241351a9 inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a79686c2174ab01dc23394953955ff003 inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003">slot_list_type</a></td></tr>
+<tr class="separator:a79686c2174ab01dc23394953955ff003 inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a72ee8c51eea3d1ba99eb9b512dfccd81 inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(<a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a></td></tr>
+<tr class="separator:a72ee8c51eea3d1ba99eb9b512dfccd81 inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1 = nil, class T_arg2 = nil, class T_arg3 = nil, class T_arg4 = nil, class T_arg5 = nil, class T_arg6 = nil, class T_arg7 = nil><br />
+class sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates. </p>
+<p>signal can be used to <a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2" title="Add a slot to the list of slots.">connect()</a> slots that are invoked during subsequent calls to <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a>. Any functor or slot can be passed into <a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2" title="Add a slot to the list of slots.">connect()</a>. It is converted into a slot implicitly.</p>
+<p>If you want to connect one signal to another, use <a class="el" href="classsigc_1_1signal7.html#a3f468c8b6cc55d675c75d0184bd8e38a" title="Creates a functor that calls emit() on this signal.">make_slot()</a> to retrieve a functor that emits the signal when invoked.</p>
+<p>Be careful if you directly pass one signal into the <a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2" title="Add a slot to the list of slots.">connect()</a> 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!</p>
+<p>The template arguments determine the function signature of the <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a> function:</p><ul>
+<li><em>T_return</em> The desired return type of the <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a> function.</li>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg6</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg7</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a>. The default <code>nil</code> means no argument.</li>
+</ul>
+<p>To specify an accumulator type the nested class <a class="el" href="classsigc_1_1signal_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal# templates.">signal::accumulated</a> can be used.</p>
+<dl class="section user"><dt>Example:</dt><dd><div class="fragment"><div class="line"><span class="keywordtype">void</span> foo(<span class="keywordtype">int</span>) {}</div>
+<div class="line"><a class="code" href="classsigc_1_1signal.html">sigc::signal<void, long></a> sig;</div>
+<div class="line">sig.<a class="code" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">connect</a>(<a class="code" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863">sigc::ptr_fun</a>(&foo));</div>
+<div class="line">sig.<a class="code" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2">emit</a>(19);</div>
+<div class="ttc" id="aclasssigc_1_1signal7_html_adc55ac9b0f935fd87a67904022e03cb2"><div class="ttname"><a href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">sigc::signal7::connect</a></div><div class="ttdeci">iterator connect(const slot_type &slot_)</div><div class="ttdoc">Add a slot to the list of slots.</div><div class="ttdef"><b>Definition:</b> signal.h:3871</div></div>
+<div class="ttc" id="aclasssigc_1_1signal7_html_aead3b0e97ed0bd95f870b1956bff83c2"><div class="ttname"><a href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2">sigc::signal7::emit</a></div><div class="ttdeci">result_type emit(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</div><div class="ttdoc">Triggers the emission of the signal.</div><div class="ttdef"><b>Definition:</b> signal.h:3898</div></div>
+<div class="ttc" id="aclasssigc_1_1signal_html"><div class="ttname"><a href="classsigc_1_1signal.html">sigc::signal</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::signal# templates.</div><div class="ttdef"><b>Definition:</b> signal.h:4015</div></div>
+<div class="ttc" id="agroup__ptr__fun_html_ga9c80de72f656fb05e81fda622dddc863"><div class="ttname"><a href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863">sigc::ptr_fun</a></div><div class="ttdeci">pointer_functor0< T_return > ptr_fun(T_return(*_A_func)())</div><div class="ttdoc">Creates a functor of type sigc::pointer_functor0 which wraps an existing non-member function.</div><div class="ttdef"><b>Definition:</b> ptr_fun.h:460</div></div>
+</div><!-- fragment --></dd></dl>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000001">Deprecated:</a></b></dt><dd>Please use the syntax similar to that used by std::function<>: </dd></dl>
+<div class="fragment"><div class="line"><a class="code" href="classsigc_1_1slot.html">sigc::slot</a><void(<span class="keywordtype">bool</span>, <span class="keywordtype">int</span>)> some_slot;</div>
+<div class="ttc" id="aclasssigc_1_1slot_html"><div class="ttname"><a href="classsigc_1_1slot.html">sigc::slot</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::slot# templates.</div><div class="ttdef"><b>Definition:</b> slot.h:1645</div></div>
+</div><!-- fragment --> </div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a50432d1aebfbee5ef17a3f434d0c50bf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a50432d1aebfbee5ef17a3f434d0c50bf">◆ </a></span>signal() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 = nil, class T_arg2 = nil, class T_arg3 = nil, class T_arg4 = nil, class T_arg5 = nil, class T_arg6 = nil, class T_arg7 = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a271b486daa2bf801ed7d019da9aa33a1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a271b486daa2bf801ed7d019da9aa33a1">◆ </a></span>signal() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 = nil, class T_arg2 = nil, class T_arg3 = nil, class T_arg4 = nil, class T_arg5 = nil, class T_arg6 = nil, class T_arg7 = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="abc17a093db8ae8a0a8333c7f35f64bd6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abc17a093db8ae8a0a8333c7f35f64bd6">◆ </a></span>signal() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 = nil, class T_arg2 = nil, class T_arg3 = nil, class T_arg4 = nil, class T_arg5 = nil, class T_arg6 = nil, class T_arg7 = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="adeccc0c1c698e33c1da15c7f667f2a23"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#adeccc0c1c698e33c1da15c7f667f2a23">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 = nil, class T_arg2 = nil, class T_arg3 = nil, class T_arg4 = nil, class T_arg5 = nil, class T_arg6 = nil, class T_arg7 = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="abca2c029617e5b39f2852ee0381e7f9e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abca2c029617e5b39f2852ee0381e7f9e">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 = nil, class T_arg2 = nil, class T_arg3 = nil, class T_arg4 = nil, class T_arg5 = nil, class T_arg6 = nil, class T_arg7 = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal0.html">signal0</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal0< T_return, T_accumulator > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a609b1e0770f47c9081a3de56b65314d2">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a9b78954271b6dba5e926bd960f3e7905">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ad4f7c62954f5c270e115d9b2a2df15ea">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a476f559a69eef5999c99cd6262a9aa2f">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8">emit</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#abdae39f9a7abd6133c03d65224c227d6">emit_reverse</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ac7eafdced2d325d6003327b4360bc2dd">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ad61e875748cf4e1c2a6d89a930ae093e">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a3295536428e5e0d6478ac10e2daff736">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a2dd3042c0681542ed6f2de5840f713a1">operator()</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a4e8311eac2fd7f8ecd10bff8225ed9e3">operator=</a>(const signal0 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a693aa3743236012416349bfac56d31b6">operator=</a>(signal0 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a1d9c390974304392ed12ee81543ab997">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a2fb24e11a8f645e5122646ea2b4a5d2f">signal0</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a7dc687f1afb4088a3d888aa05dbf56d9">signal0</a>(const signal0 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ac1b915a86d0b75fd4e90c2a92f7ebc49">signal0</a>(signal0 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#add195c1c738ee8efe10294f21d258b77">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a5576113ddfd6b92a96f86072262307f9">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a73523d71edd7fb4294324e9561db6f3c">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal0< T_return, T_accumulator > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal0.html">signal0</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal0-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal0< T_return, T_accumulator > Class Template Reference<div class="ingroups"><a class="el" href="group__signal.html">Signals</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Signal declaration.
+ <a href="classsigc_1_1signal0.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal0< T_return, T_accumulator >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal0__inherit__graph.png" border="0" usemap="#asigc_1_1signal0_3_01T__return_00_01T__accumulator_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal0_3_01T__return_00_01T__accumulator_01_4_inherit__map" id="asigc_1_1signal0_3_01T__return_00_01T__accumulator_01_4_inherit__map">
+<area shape="rect" title="Signal declaration." alt="" coords="5,155,181,196"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="27,80,160,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="35,5,151,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:ad4f7c62954f5c270e115d9b2a2df15ea"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ad4f7c62954f5c270e115d9b2a2df15ea">const_iterator</a></td></tr>
+<tr class="separator:ad4f7c62954f5c270e115d9b2a2df15ea"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a476f559a69eef5999c99cd6262a9aa2f"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a476f559a69eef5999c99cd6262a9aa2f">const_reverse_iterator</a></td></tr>
+<tr class="separator:a476f559a69eef5999c99cd6262a9aa2f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac7eafdced2d325d6003327b4360bc2dd"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit0< T_return, T_accumulator > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ac7eafdced2d325d6003327b4360bc2dd">emitter_type</a></td></tr>
+<tr class="separator:ac7eafdced2d325d6003327b4360bc2dd"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad61e875748cf4e1c2a6d89a930ae093e"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ad61e875748cf4e1c2a6d89a930ae093e">iterator</a></td></tr>
+<tr class="separator:ad61e875748cf4e1c2a6d89a930ae093e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae291a90c83f8ad1cdcc7c2a4cdd958de"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a></td></tr>
+<tr class="separator:ae291a90c83f8ad1cdcc7c2a4cdd958de"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1d9c390974304392ed12ee81543ab997"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a1d9c390974304392ed12ee81543ab997">reverse_iterator</a></td></tr>
+<tr class="separator:a1d9c390974304392ed12ee81543ab997"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:add195c1c738ee8efe10294f21d258b77"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#add195c1c738ee8efe10294f21d258b77">slot_list_type</a></td></tr>
+<tr class="separator:add195c1c738ee8efe10294f21d258b77"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae3fc90cec344b6585979e77d2b359287"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return()> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a></td></tr>
+<tr class="separator:ae3fc90cec344b6585979e77d2b359287"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a2fb24e11a8f645e5122646ea2b4a5d2f"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a2fb24e11a8f645e5122646ea2b4a5d2f">signal0</a> ()</td></tr>
+<tr class="separator:a2fb24e11a8f645e5122646ea2b4a5d2f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7dc687f1afb4088a3d888aa05dbf56d9"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a7dc687f1afb4088a3d888aa05dbf56d9">signal0</a> (const <a class="el" href="classsigc_1_1signal0.html">signal0</a> & src)</td></tr>
+<tr class="separator:a7dc687f1afb4088a3d888aa05dbf56d9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac1b915a86d0b75fd4e90c2a92f7ebc49"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ac1b915a86d0b75fd4e90c2a92f7ebc49">signal0</a> (<a class="el" href="classsigc_1_1signal0.html">signal0</a> && src)</td></tr>
+<tr class="separator:ac1b915a86d0b75fd4e90c2a92f7ebc49"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a609b1e0770f47c9081a3de56b65314d2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#ad61e875748cf4e1c2a6d89a930ae093e">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a609b1e0770f47c9081a3de56b65314d2">connect</a> (const <a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:a609b1e0770f47c9081a3de56b65314d2"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal0.html#a609b1e0770f47c9081a3de56b65314d2">More...</a><br /></td></tr>
+<tr class="separator:a609b1e0770f47c9081a3de56b65314d2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9b78954271b6dba5e926bd960f3e7905"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#ad61e875748cf4e1c2a6d89a930ae093e">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a9b78954271b6dba5e926bd960f3e7905">connect</a> (<a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:a9b78954271b6dba5e926bd960f3e7905"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal0.html#a9b78954271b6dba5e926bd960f3e7905">More...</a><br /></td></tr>
+<tr class="separator:a9b78954271b6dba5e926bd960f3e7905"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a655829125186645bcbc61db8252134a8"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8">emit</a> () const</td></tr>
+<tr class="memdesc:a655829125186645bcbc61db8252134a8"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8">More...</a><br /></td></tr>
+<tr class="separator:a655829125186645bcbc61db8252134a8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abdae39f9a7abd6133c03d65224c227d6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#abdae39f9a7abd6133c03d65224c227d6">emit_reverse</a> () const</td></tr>
+<tr class="memdesc:abdae39f9a7abd6133c03d65224c227d6"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal0.html#abdae39f9a7abd6133c03d65224c227d6">More...</a><br /></td></tr>
+<tr class="separator:abdae39f9a7abd6133c03d65224c227d6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3295536428e5e0d6478ac10e2daff736"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html">bound_const_mem_functor0</a>< <a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a>, <a class="el" href="classsigc_1_1signal0.html">signal0</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a3295536428e5e0d6478ac10e2daff736">make_slot</a> () const</td></tr>
+<tr class="memdesc:a3295536428e5e0d6478ac10e2daff736"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal0.html#a3295536428e5e0d6478ac10e2daff736">More...</a><br /></td></tr>
+<tr class="separator:a3295536428e5e0d6478ac10e2daff736"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2dd3042c0681542ed6f2de5840f713a1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a2dd3042c0681542ed6f2de5840f713a1">operator()</a> () const</td></tr>
+<tr class="memdesc:a2dd3042c0681542ed6f2de5840f713a1"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal0.html#a2dd3042c0681542ed6f2de5840f713a1">More...</a><br /></td></tr>
+<tr class="separator:a2dd3042c0681542ed6f2de5840f713a1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4e8311eac2fd7f8ecd10bff8225ed9e3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html">signal0</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a4e8311eac2fd7f8ecd10bff8225ed9e3">operator=</a> (const <a class="el" href="classsigc_1_1signal0.html">signal0</a> & src)</td></tr>
+<tr class="separator:a4e8311eac2fd7f8ecd10bff8225ed9e3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a693aa3743236012416349bfac56d31b6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html">signal0</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a693aa3743236012416349bfac56d31b6">operator=</a> (<a class="el" href="classsigc_1_1signal0.html">signal0</a> && src)</td></tr>
+<tr class="separator:a693aa3743236012416349bfac56d31b6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5576113ddfd6b92a96f86072262307f9"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#add195c1c738ee8efe10294f21d258b77">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a5576113ddfd6b92a96f86072262307f9">slots</a> ()</td></tr>
+<tr class="memdesc:a5576113ddfd6b92a96f86072262307f9"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal0.html#a5576113ddfd6b92a96f86072262307f9">More...</a><br /></td></tr>
+<tr class="separator:a5576113ddfd6b92a96f86072262307f9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a73523d71edd7fb4294324e9561db6f3c"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal0.html#add195c1c738ee8efe10294f21d258b77">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a73523d71edd7fb4294324e9561db6f3c">slots</a> () const</td></tr>
+<tr class="memdesc:a73523d71edd7fb4294324e9561db6f3c"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal0.html#a73523d71edd7fb4294324e9561db6f3c">More...</a><br /></td></tr>
+<tr class="separator:a73523d71edd7fb4294324e9561db6f3c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_accumulator = nil><br />
+class sigc::signal0< T_return, T_accumulator ></h3>
+
+<p>Signal declaration. </p>
+<p><a class="el" href="classsigc_1_1signal0.html" title="Signal declaration.">signal0</a> can be used to <a class="el" href="classsigc_1_1signal0.html#a609b1e0770f47c9081a3de56b65314d2" title="Add a slot to the list of slots.">connect()</a> slots that are invoked during subsequent calls to <a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8" title="Triggers the emission of the signal.">emit()</a>. Any functor or slot can be passed into <a class="el" href="classsigc_1_1signal0.html#a609b1e0770f47c9081a3de56b65314d2" title="Add a slot to the list of slots.">connect()</a>. It is converted into a slot implicitly.</p>
+<p>If you want to connect one signal to another, use <a class="el" href="classsigc_1_1signal0.html#a3295536428e5e0d6478ac10e2daff736" title="Creates a functor that calls emit() on this signal.">make_slot()</a> to retrieve a functor that emits the signal when invoked.</p>
+<p>Be careful if you directly pass one signal into the <a class="el" href="classsigc_1_1signal0.html#a609b1e0770f47c9081a3de56b65314d2" title="Add a slot to the list of slots.">connect()</a> 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.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_return</em> The desired return type for the <a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8" title="Triggers the emission of the signal.">emit()</a> function (may be overridden by the accumulator).</li>
+<li><em>T_accumulator</em> The accumulator type used for emission. The default <code>nil</code> means that no accumulator should be used, for example if signal emission returns the return value of the last slot invoked.</li>
+</ul>
+<p>You should use the more convenient unnumbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> template. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="ad4f7c62954f5c270e115d9b2a2df15ea"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad4f7c62954f5c270e115d9b2a2df15ea">◆ </a></span>const_iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> <a class="el" href="classsigc_1_1signal0.html">sigc::signal0</a>< T_return, T_accumulator >::<a class="el" href="classsigc_1_1signal0.html#ad4f7c62954f5c270e115d9b2a2df15ea">const_iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a476f559a69eef5999c99cd6262a9aa2f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a476f559a69eef5999c99cd6262a9aa2f">◆ </a></span>const_reverse_iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> <a class="el" href="classsigc_1_1signal0.html">sigc::signal0</a>< T_return, T_accumulator >::<a class="el" href="classsigc_1_1signal0.html#a476f559a69eef5999c99cd6262a9aa2f">const_reverse_iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ac7eafdced2d325d6003327b4360bc2dd"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac7eafdced2d325d6003327b4360bc2dd">◆ </a></span>emitter_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef internal::signal_emit0<T_return, T_accumulator> <a class="el" href="classsigc_1_1signal0.html">sigc::signal0</a>< T_return, T_accumulator >::<a class="el" href="classsigc_1_1signal0.html#ac7eafdced2d325d6003327b4360bc2dd">emitter_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ad61e875748cf4e1c2a6d89a930ae093e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad61e875748cf4e1c2a6d89a930ae093e">◆ </a></span>iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> <a class="el" href="classsigc_1_1signal0.html">sigc::signal0</a>< T_return, T_accumulator >::<a class="el" href="classsigc_1_1signal0.html#ad61e875748cf4e1c2a6d89a930ae093e">iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ae291a90c83f8ad1cdcc7c2a4cdd958de"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae291a90c83f8ad1cdcc7c2a4cdd958de">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef emitter_type::result_type <a class="el" href="classsigc_1_1signal0.html">sigc::signal0</a>< T_return, T_accumulator >::<a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a1d9c390974304392ed12ee81543ab997"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1d9c390974304392ed12ee81543ab997">◆ </a></span>reverse_iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> <a class="el" href="classsigc_1_1signal0.html">sigc::signal0</a>< T_return, T_accumulator >::<a class="el" href="classsigc_1_1signal0.html#a1d9c390974304392ed12ee81543ab997">reverse_iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="add195c1c738ee8efe10294f21d258b77"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#add195c1c738ee8efe10294f21d258b77">◆ </a></span>slot_list_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a><<a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a>> <a class="el" href="classsigc_1_1signal0.html">sigc::signal0</a>< T_return, T_accumulator >::<a class="el" href="classsigc_1_1signal0.html#add195c1c738ee8efe10294f21d258b77">slot_list_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ae3fc90cec344b6585979e77d2b359287"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae3fc90cec344b6585979e77d2b359287">◆ </a></span>slot_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="classsigc_1_1slot.html">slot</a><T_return()> <a class="el" href="classsigc_1_1signal0.html">sigc::signal0</a>< T_return, T_accumulator >::<a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a2fb24e11a8f645e5122646ea2b4a5d2f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2fb24e11a8f645e5122646ea2b4a5d2f">◆ </a></span>signal0() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0</a>< T_return, T_accumulator >::<a class="el" href="classsigc_1_1signal0.html">signal0</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a7dc687f1afb4088a3d888aa05dbf56d9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7dc687f1afb4088a3d888aa05dbf56d9">◆ </a></span>signal0() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0</a>< T_return, T_accumulator >::<a class="el" href="classsigc_1_1signal0.html">signal0</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal0.html">signal0</a>< T_return, T_accumulator > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ac1b915a86d0b75fd4e90c2a92f7ebc49"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac1b915a86d0b75fd4e90c2a92f7ebc49">◆ </a></span>signal0() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0</a>< T_return, T_accumulator >::<a class="el" href="classsigc_1_1signal0.html">signal0</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal0.html">signal0</a>< T_return, T_accumulator > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a609b1e0770f47c9081a3de56b65314d2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a609b1e0770f47c9081a3de56b65314d2">◆ </a></span>connect() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal0.html#ad61e875748cf4e1c2a6d89a930ae093e">iterator</a> <a class="el" href="classsigc_1_1signal0.html">sigc::signal0</a>< T_return, T_accumulator >::connect </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a> & </td>
+ <td class="paramname"><em>slot_</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Add a slot to the list of slots. </p>
+<p>Any functor or slot may be passed into <a class="el" href="classsigc_1_1signal0.html#a609b1e0770f47c9081a3de56b65314d2" title="Add a slot to the list of slots.">connect()</a>. 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 <a class="el" href="structsigc_1_1connection.html" title="Convinience class for safe disconnection.">sigc::connection</a> object that may be used safely beyond the life time of the slot.</p>
+<p>std::function<> and C++11 lambda expressions are functors. These are examples of functors that can be connected to a signal.</p>
+<p>std::bind() creates a functor, but this functor typically has an operator()() which is a variadic template. Our <a class="el" href="structsigc_1_1functor__trait.html" title="Trait that specifies the return type of any type.">functor_trait</a> 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.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">slot_</td><td>The slot to add to the list of slots. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>An iterator pointing to the new slot in the list. </dd></dl>
+
+</div>
+</div>
+<a id="a9b78954271b6dba5e926bd960f3e7905"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9b78954271b6dba5e926bd960f3e7905">◆ </a></span>connect() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal0.html#ad61e875748cf4e1c2a6d89a930ae093e">iterator</a> <a class="el" href="classsigc_1_1signal0.html">sigc::signal0</a>< T_return, T_accumulator >::connect </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a> && </td>
+ <td class="paramname"><em>slot_</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Add a slot to the list of slots. </p>
+<dl class="section see"><dt>See also</dt><dd><a class="el" href="classsigc_1_1signal0.html#a609b1e0770f47c9081a3de56b65314d2" title="Add a slot to the list of slots.">connect(const slot_type& slot_)</a>.</dd></dl>
+<dl class="since_2_8"><dt><b><a class="el" href="since_2_8.html#_since_2_8000001">Since libsigc++ 2.8:</a></b></dt><dd></dd></dl>
+
+</div>
+</div>
+<a id="a655829125186645bcbc61db8252134a8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a655829125186645bcbc61db8252134a8">◆ </a></span>emit()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a> <a class="el" href="classsigc_1_1signal0.html">sigc::signal0</a>< T_return, T_accumulator >::emit </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Triggers the emission of the signal. </p>
+<p>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 <em>T_accumulated</em> is not <code>nil</code>, 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. </p><dl class="section return"><dt>Returns</dt><dd>The accumulated return values of the slot invocations. </dd></dl>
+
+</div>
+</div>
+<a id="abdae39f9a7abd6133c03d65224c227d6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abdae39f9a7abd6133c03d65224c227d6">◆ </a></span>emit_reverse()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a> <a class="el" href="classsigc_1_1signal0.html">sigc::signal0</a>< T_return, T_accumulator >::emit_reverse </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8" title="Triggers the emission of the signal.">emit()</a>). </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000033">Deprecated:</a></b></dt><dd>This is apparently not useful, but please let us know if you need it. </dd></dl>
+
+</div>
+</div>
+<a id="a3295536428e5e0d6478ac10e2daff736"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3295536428e5e0d6478ac10e2daff736">◆ </a></span>make_slot()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html">bound_const_mem_functor0</a><<a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a>, <a class="el" href="classsigc_1_1signal0.html">signal0</a>> <a class="el" href="classsigc_1_1signal0.html">sigc::signal0</a>< T_return, T_accumulator >::make_slot </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor that calls <a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8" title="Triggers the emission of the signal.">emit()</a> on this signal. </p>
+<div class="fragment"><div class="line"><a class="code" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">sigc::mem_fun</a>(mysignal, &<a class="code" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8">sigc::signal0::emit</a>)</div>
+<div class="ttc" id="aclasssigc_1_1signal0_html_a655829125186645bcbc61db8252134a8"><div class="ttname"><a href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8">sigc::signal0::emit</a></div><div class="ttdeci">result_type emit() const</div><div class="ttdoc">Triggers the emission of the signal.</div><div class="ttdef"><b>Definition:</b> signal.h:2799</div></div>
+<div class="ttc" id="agroup__mem__fun_html_gadf6b6d22c503b439019f0a2e77352419"><div class="ttname"><a href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">sigc::mem_fun</a></div><div class="ttdeci">mem_functor0< T_return, T_obj > mem_fun(T_return(T_obj::*_A_func)())</div><div class="ttdoc">Creates a functor of type sigc::mem_functor0 which wraps a method.</div><div class="ttdef"><b>Definition:</b> mem_fun.h:5797</div></div>
+</div><!-- fragment --><p> yields the same result. </p><dl class="section return"><dt>Returns</dt><dd>A functor that calls <a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8" title="Triggers the emission of the signal.">emit()</a> on this signal. </dd></dl>
+
+</div>
+</div>
+<a id="a2dd3042c0681542ed6f2de5840f713a1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2dd3042c0681542ed6f2de5840f713a1">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a> <a class="el" href="classsigc_1_1signal0.html">sigc::signal0</a>< T_return, T_accumulator >::operator() </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8" title="Triggers the emission of the signal.">emit()</a>). </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000034">Deprecated:</a></b></dt><dd>This is apparently not useful, but let us know if you need it. </dd></dl>
+
+</div>
+</div>
+<a id="a4e8311eac2fd7f8ecd10bff8225ed9e3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4e8311eac2fd7f8ecd10bff8225ed9e3">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal0.html">signal0</a>& <a class="el" href="classsigc_1_1signal0.html">sigc::signal0</a>< T_return, T_accumulator >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal0.html">signal0</a>< T_return, T_accumulator > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a693aa3743236012416349bfac56d31b6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a693aa3743236012416349bfac56d31b6">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal0.html">signal0</a>& <a class="el" href="classsigc_1_1signal0.html">sigc::signal0</a>< T_return, T_accumulator >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal0.html">signal0</a>< T_return, T_accumulator > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a5576113ddfd6b92a96f86072262307f9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5576113ddfd6b92a96f86072262307f9">◆ </a></span>slots() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal0.html#add195c1c738ee8efe10294f21d258b77">slot_list_type</a> <a class="el" href="classsigc_1_1signal0.html">sigc::signal0</a>< T_return, T_accumulator >::slots </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an STL-style interface for the signal's list of slots. </p>
+<p>This interface supports iteration, insertion and removal of slots. </p><dl class="section return"><dt>Returns</dt><dd>An STL-style interface for the signal's list of slots.</dd></dl>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000035">Deprecated:</a></b></dt><dd>This is apparently not useful, but please let us know if you need it. </dd></dl>
+
+</div>
+</div>
+<a id="a73523d71edd7fb4294324e9561db6f3c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a73523d71edd7fb4294324e9561db6f3c">◆ </a></span>slots() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">const <a class="el" href="classsigc_1_1signal0.html#add195c1c738ee8efe10294f21d258b77">slot_list_type</a> <a class="el" href="classsigc_1_1signal0.html">sigc::signal0</a>< T_return, T_accumulator >::slots </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an STL-style interface for the signal's list of slots. </p>
+<p>This interface supports iteration, insertion and removal of slots. </p><dl class="section return"><dt>Returns</dt><dd>An STL-style interface for the signal's list of slots.</dd></dl>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000036">Deprecated:</a></b></dt><dd>This is apparently not useful, but please let us know if you need it. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal0< T_return, T_accumulator >" name="sigc::signal0< T_return, T_accumulator >">
+<area shape="rect" id="node1" title="Signal declaration." alt="" coords="5,155,181,196"/>
+<area shape="rect" id="node2" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="27,80,160,107"/>
+<area shape="rect" id="node3" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="35,5,151,32"/>
+</map>
--- /dev/null
+7b5f68090918a17c201cbbfce11ef763
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal1.html">signal1</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal1< T_return, T_arg1, T_accumulator > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#aac2ade0896bd4a982777d5dd6ac75888">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#ac69d2681c586b310d8c056a319bb65fe">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#af1e262b35c9574e65b2607cdfcaad707">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#aeb327519f808dfec9a723511ef82caa3">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42">emit</a>(type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a449fc940ae822c4b6ea9282b9b292015">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a63c6e2b55c8c3af083402bb7f5a66593">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#ab61e2d1fcaf903dffbb26b01800907fb">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a87513117263fd39d5a5a86e0fb8b2a78">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a828907c11f5c18d9522e5d5139484620">operator()</a>(type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a29cd06bf91f96f11c5f29237b8afbb71">operator=</a>(const signal1 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#ab817711d4bc93402d15e87b89a09c364">operator=</a>(signal1 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#ab0443049aa736d88770d0f534600b2bc">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#aba62d8d0b9591bcfd728f8ae8a22d600">signal1</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#ab3378dd754ffddb4760f2a3afb271dbe">signal1</a>(const signal1 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a85ec968e0b25ee9285f297da5416b2a4">signal1</a>(signal1 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a5fadeb350140d6aaf560b217e7e7c4b4">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a7653b68e6a3b8445de91f89060bf2600">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a7777660b21fef2a6941c7dff23964604">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal1< T_return, T_arg1, T_accumulator > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal1.html">signal1</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal1-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal1< T_return, T_arg1, T_accumulator > Class Template Reference<div class="ingroups"><a class="el" href="group__signal.html">Signals</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Signal declaration.
+ <a href="classsigc_1_1signal1.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal1< T_return, T_arg1, T_accumulator >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal1__inherit__graph.png" border="0" usemap="#asigc_1_1signal1_3_01T__return_00_01T__arg1_00_01T__accumulator_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal1_3_01T__return_00_01T__arg1_00_01T__accumulator_01_4_inherit__map" id="asigc_1_1signal1_3_01T__return_00_01T__arg1_00_01T__accumulator_01_4_inherit__map">
+<area shape="rect" title="Signal declaration." alt="" coords="5,155,195,196"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="33,80,167,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="42,5,158,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:af1e262b35c9574e65b2607cdfcaad707"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#af1e262b35c9574e65b2607cdfcaad707">const_iterator</a></td></tr>
+<tr class="separator:af1e262b35c9574e65b2607cdfcaad707"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aeb327519f808dfec9a723511ef82caa3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#aeb327519f808dfec9a723511ef82caa3">const_reverse_iterator</a></td></tr>
+<tr class="separator:aeb327519f808dfec9a723511ef82caa3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a63c6e2b55c8c3af083402bb7f5a66593"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit1< T_return, T_arg1, T_accumulator > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a63c6e2b55c8c3af083402bb7f5a66593">emitter_type</a></td></tr>
+<tr class="separator:a63c6e2b55c8c3af083402bb7f5a66593"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab61e2d1fcaf903dffbb26b01800907fb"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#ab61e2d1fcaf903dffbb26b01800907fb">iterator</a></td></tr>
+<tr class="separator:ab61e2d1fcaf903dffbb26b01800907fb"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adcdcfa50d60e1832ce038a4a5554fce1"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a></td></tr>
+<tr class="separator:adcdcfa50d60e1832ce038a4a5554fce1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0443049aa736d88770d0f534600b2bc"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#ab0443049aa736d88770d0f534600b2bc">reverse_iterator</a></td></tr>
+<tr class="separator:ab0443049aa736d88770d0f534600b2bc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5fadeb350140d6aaf560b217e7e7c4b4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a5fadeb350140d6aaf560b217e7e7c4b4">slot_list_type</a></td></tr>
+<tr class="separator:a5fadeb350140d6aaf560b217e7e7c4b4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a310736e1415c2cf4578892ffff35915c"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a></td></tr>
+<tr class="separator:a310736e1415c2cf4578892ffff35915c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:aba62d8d0b9591bcfd728f8ae8a22d600"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#aba62d8d0b9591bcfd728f8ae8a22d600">signal1</a> ()</td></tr>
+<tr class="separator:aba62d8d0b9591bcfd728f8ae8a22d600"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab3378dd754ffddb4760f2a3afb271dbe"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#ab3378dd754ffddb4760f2a3afb271dbe">signal1</a> (const <a class="el" href="classsigc_1_1signal1.html">signal1</a> & src)</td></tr>
+<tr class="separator:ab3378dd754ffddb4760f2a3afb271dbe"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a85ec968e0b25ee9285f297da5416b2a4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a85ec968e0b25ee9285f297da5416b2a4">signal1</a> (<a class="el" href="classsigc_1_1signal1.html">signal1</a> && src)</td></tr>
+<tr class="separator:a85ec968e0b25ee9285f297da5416b2a4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aac2ade0896bd4a982777d5dd6ac75888"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#ab61e2d1fcaf903dffbb26b01800907fb">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#aac2ade0896bd4a982777d5dd6ac75888">connect</a> (const <a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:aac2ade0896bd4a982777d5dd6ac75888"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal1.html#aac2ade0896bd4a982777d5dd6ac75888">More...</a><br /></td></tr>
+<tr class="separator:aac2ade0896bd4a982777d5dd6ac75888"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac69d2681c586b310d8c056a319bb65fe"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#ab61e2d1fcaf903dffbb26b01800907fb">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#ac69d2681c586b310d8c056a319bb65fe">connect</a> (<a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:ac69d2681c586b310d8c056a319bb65fe"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal1.html#ac69d2681c586b310d8c056a319bb65fe">More...</a><br /></td></tr>
+<tr class="separator:ac69d2681c586b310d8c056a319bb65fe"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:affe595f8b70b4f43a21be7192c0cba42"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:affe595f8b70b4f43a21be7192c0cba42"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42">More...</a><br /></td></tr>
+<tr class="separator:affe595f8b70b4f43a21be7192c0cba42"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a449fc940ae822c4b6ea9282b9b292015"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a449fc940ae822c4b6ea9282b9b292015">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a449fc940ae822c4b6ea9282b9b292015"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal1.html#a449fc940ae822c4b6ea9282b9b292015">More...</a><br /></td></tr>
+<tr class="separator:a449fc940ae822c4b6ea9282b9b292015"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87513117263fd39d5a5a86e0fb8b2a78"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html">bound_const_mem_functor1</a>< <a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a>, <a class="el" href="classsigc_1_1signal1.html">signal1</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a87513117263fd39d5a5a86e0fb8b2a78">make_slot</a> () const</td></tr>
+<tr class="memdesc:a87513117263fd39d5a5a86e0fb8b2a78"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal1.html#a87513117263fd39d5a5a86e0fb8b2a78">More...</a><br /></td></tr>
+<tr class="separator:a87513117263fd39d5a5a86e0fb8b2a78"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a828907c11f5c18d9522e5d5139484620"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a828907c11f5c18d9522e5d5139484620">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a828907c11f5c18d9522e5d5139484620"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal1.html#a828907c11f5c18d9522e5d5139484620">More...</a><br /></td></tr>
+<tr class="separator:a828907c11f5c18d9522e5d5139484620"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a29cd06bf91f96f11c5f29237b8afbb71"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html">signal1</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a29cd06bf91f96f11c5f29237b8afbb71">operator=</a> (const <a class="el" href="classsigc_1_1signal1.html">signal1</a> & src)</td></tr>
+<tr class="separator:a29cd06bf91f96f11c5f29237b8afbb71"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab817711d4bc93402d15e87b89a09c364"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html">signal1</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#ab817711d4bc93402d15e87b89a09c364">operator=</a> (<a class="el" href="classsigc_1_1signal1.html">signal1</a> && src)</td></tr>
+<tr class="separator:ab817711d4bc93402d15e87b89a09c364"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7653b68e6a3b8445de91f89060bf2600"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#a5fadeb350140d6aaf560b217e7e7c4b4">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a7653b68e6a3b8445de91f89060bf2600">slots</a> ()</td></tr>
+<tr class="memdesc:a7653b68e6a3b8445de91f89060bf2600"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal1.html#a7653b68e6a3b8445de91f89060bf2600">More...</a><br /></td></tr>
+<tr class="separator:a7653b68e6a3b8445de91f89060bf2600"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7777660b21fef2a6941c7dff23964604"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal1.html#a5fadeb350140d6aaf560b217e7e7c4b4">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a7777660b21fef2a6941c7dff23964604">slots</a> () const</td></tr>
+<tr class="memdesc:a7777660b21fef2a6941c7dff23964604"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal1.html#a7777660b21fef2a6941c7dff23964604">More...</a><br /></td></tr>
+<tr class="separator:a7777660b21fef2a6941c7dff23964604"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_accumulator = nil><br />
+class sigc::signal1< T_return, T_arg1, T_accumulator ></h3>
+
+<p>Signal declaration. </p>
+<p><a class="el" href="classsigc_1_1signal1.html" title="Signal declaration.">signal1</a> can be used to <a class="el" href="classsigc_1_1signal1.html#aac2ade0896bd4a982777d5dd6ac75888" title="Add a slot to the list of slots.">connect()</a> slots that are invoked during subsequent calls to <a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42" title="Triggers the emission of the signal.">emit()</a>. Any functor or slot can be passed into <a class="el" href="classsigc_1_1signal1.html#aac2ade0896bd4a982777d5dd6ac75888" title="Add a slot to the list of slots.">connect()</a>. It is converted into a slot implicitly.</p>
+<p>If you want to connect one signal to another, use <a class="el" href="classsigc_1_1signal1.html#a87513117263fd39d5a5a86e0fb8b2a78" title="Creates a functor that calls emit() on this signal.">make_slot()</a> to retrieve a functor that emits the signal when invoked.</p>
+<p>Be careful if you directly pass one signal into the <a class="el" href="classsigc_1_1signal1.html#aac2ade0896bd4a982777d5dd6ac75888" title="Add a slot to the list of slots.">connect()</a> 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.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_return</em> The desired return type for the <a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42" title="Triggers the emission of the signal.">emit()</a> function (may be overridden by the accumulator).</li>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42" title="Triggers the emission of the signal.">emit()</a>.</li>
+<li><em>T_accumulator</em> The accumulator type used for emission. The default <code>nil</code> means that no accumulator should be used, for example if signal emission returns the return value of the last slot invoked.</li>
+</ul>
+<p>You should use the more convenient unnumbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> template. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="af1e262b35c9574e65b2607cdfcaad707"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af1e262b35c9574e65b2607cdfcaad707">◆ </a></span>const_iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> <a class="el" href="classsigc_1_1signal1.html">sigc::signal1</a>< T_return, T_arg1, T_accumulator >::<a class="el" href="classsigc_1_1signal1.html#af1e262b35c9574e65b2607cdfcaad707">const_iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aeb327519f808dfec9a723511ef82caa3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aeb327519f808dfec9a723511ef82caa3">◆ </a></span>const_reverse_iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> <a class="el" href="classsigc_1_1signal1.html">sigc::signal1</a>< T_return, T_arg1, T_accumulator >::<a class="el" href="classsigc_1_1signal1.html#aeb327519f808dfec9a723511ef82caa3">const_reverse_iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a63c6e2b55c8c3af083402bb7f5a66593"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a63c6e2b55c8c3af083402bb7f5a66593">◆ </a></span>emitter_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef internal::signal_emit1<T_return, T_arg1, T_accumulator> <a class="el" href="classsigc_1_1signal1.html">sigc::signal1</a>< T_return, T_arg1, T_accumulator >::<a class="el" href="classsigc_1_1signal1.html#a63c6e2b55c8c3af083402bb7f5a66593">emitter_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ab61e2d1fcaf903dffbb26b01800907fb"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab61e2d1fcaf903dffbb26b01800907fb">◆ </a></span>iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> <a class="el" href="classsigc_1_1signal1.html">sigc::signal1</a>< T_return, T_arg1, T_accumulator >::<a class="el" href="classsigc_1_1signal1.html#ab61e2d1fcaf903dffbb26b01800907fb">iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="adcdcfa50d60e1832ce038a4a5554fce1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#adcdcfa50d60e1832ce038a4a5554fce1">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef emitter_type::result_type <a class="el" href="classsigc_1_1signal1.html">sigc::signal1</a>< T_return, T_arg1, T_accumulator >::<a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ab0443049aa736d88770d0f534600b2bc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab0443049aa736d88770d0f534600b2bc">◆ </a></span>reverse_iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> <a class="el" href="classsigc_1_1signal1.html">sigc::signal1</a>< T_return, T_arg1, T_accumulator >::<a class="el" href="classsigc_1_1signal1.html#ab0443049aa736d88770d0f534600b2bc">reverse_iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a5fadeb350140d6aaf560b217e7e7c4b4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5fadeb350140d6aaf560b217e7e7c4b4">◆ </a></span>slot_list_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a><<a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a>> <a class="el" href="classsigc_1_1signal1.html">sigc::signal1</a>< T_return, T_arg1, T_accumulator >::<a class="el" href="classsigc_1_1signal1.html#a5fadeb350140d6aaf560b217e7e7c4b4">slot_list_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a310736e1415c2cf4578892ffff35915c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a310736e1415c2cf4578892ffff35915c">◆ </a></span>slot_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="classsigc_1_1slot.html">slot</a><T_return(T_arg1)> <a class="el" href="classsigc_1_1signal1.html">sigc::signal1</a>< T_return, T_arg1, T_accumulator >::<a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="aba62d8d0b9591bcfd728f8ae8a22d600"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aba62d8d0b9591bcfd728f8ae8a22d600">◆ </a></span>signal1() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1</a>< T_return, T_arg1, T_accumulator >::<a class="el" href="classsigc_1_1signal1.html">signal1</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ab3378dd754ffddb4760f2a3afb271dbe"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab3378dd754ffddb4760f2a3afb271dbe">◆ </a></span>signal1() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1</a>< T_return, T_arg1, T_accumulator >::<a class="el" href="classsigc_1_1signal1.html">signal1</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal1.html">signal1</a>< T_return, T_arg1, T_accumulator > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a85ec968e0b25ee9285f297da5416b2a4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a85ec968e0b25ee9285f297da5416b2a4">◆ </a></span>signal1() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1</a>< T_return, T_arg1, T_accumulator >::<a class="el" href="classsigc_1_1signal1.html">signal1</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal1.html">signal1</a>< T_return, T_arg1, T_accumulator > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="aac2ade0896bd4a982777d5dd6ac75888"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aac2ade0896bd4a982777d5dd6ac75888">◆ </a></span>connect() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal1.html#ab61e2d1fcaf903dffbb26b01800907fb">iterator</a> <a class="el" href="classsigc_1_1signal1.html">sigc::signal1</a>< T_return, T_arg1, T_accumulator >::connect </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a> & </td>
+ <td class="paramname"><em>slot_</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Add a slot to the list of slots. </p>
+<p>Any functor or slot may be passed into <a class="el" href="classsigc_1_1signal1.html#aac2ade0896bd4a982777d5dd6ac75888" title="Add a slot to the list of slots.">connect()</a>. 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 <a class="el" href="structsigc_1_1connection.html" title="Convinience class for safe disconnection.">sigc::connection</a> object that may be used safely beyond the life time of the slot.</p>
+<p>std::function<> and C++11 lambda expressions are functors. These are examples of functors that can be connected to a signal.</p>
+<p>std::bind() creates a functor, but this functor typically has an operator()() which is a variadic template. Our <a class="el" href="structsigc_1_1functor__trait.html" title="Trait that specifies the return type of any type.">functor_trait</a> 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.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">slot_</td><td>The slot to add to the list of slots. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>An iterator pointing to the new slot in the list. </dd></dl>
+
+</div>
+</div>
+<a id="ac69d2681c586b310d8c056a319bb65fe"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac69d2681c586b310d8c056a319bb65fe">◆ </a></span>connect() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal1.html#ab61e2d1fcaf903dffbb26b01800907fb">iterator</a> <a class="el" href="classsigc_1_1signal1.html">sigc::signal1</a>< T_return, T_arg1, T_accumulator >::connect </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a> && </td>
+ <td class="paramname"><em>slot_</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Add a slot to the list of slots. </p>
+<dl class="section see"><dt>See also</dt><dd><a class="el" href="classsigc_1_1signal1.html#aac2ade0896bd4a982777d5dd6ac75888" title="Add a slot to the list of slots.">connect(const slot_type& slot_)</a>.</dd></dl>
+<dl class="since_2_8"><dt><b><a class="el" href="since_2_8.html#_since_2_8000002">Since libsigc++ 2.8:</a></b></dt><dd></dd></dl>
+
+</div>
+</div>
+<a id="affe595f8b70b4f43a21be7192c0cba42"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#affe595f8b70b4f43a21be7192c0cba42">◆ </a></span>emit()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a> <a class="el" href="classsigc_1_1signal1.html">sigc::signal1</a>< T_return, T_arg1, T_accumulator >::emit </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Triggers the emission of the signal. </p>
+<p>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 <em>T_accumulated</em> is not <code>nil</code>, 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. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the slots. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The accumulated return values of the slot invocations. </dd></dl>
+
+</div>
+</div>
+<a id="a449fc940ae822c4b6ea9282b9b292015"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a449fc940ae822c4b6ea9282b9b292015">◆ </a></span>emit_reverse()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a> <a class="el" href="classsigc_1_1signal1.html">sigc::signal1</a>< T_return, T_arg1, T_accumulator >::emit_reverse </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42" title="Triggers the emission of the signal.">emit()</a>). </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000037">Deprecated:</a></b></dt><dd>This is apparently not useful, but please let us know if you need it. </dd></dl>
+
+</div>
+</div>
+<a id="a87513117263fd39d5a5a86e0fb8b2a78"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a87513117263fd39d5a5a86e0fb8b2a78">◆ </a></span>make_slot()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html">bound_const_mem_functor1</a><<a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a>, <a class="el" href="classsigc_1_1signal1.html">signal1</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg1> > <a class="el" href="classsigc_1_1signal1.html">sigc::signal1</a>< T_return, T_arg1, T_accumulator >::make_slot </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor that calls <a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42" title="Triggers the emission of the signal.">emit()</a> on this signal. </p>
+<div class="fragment"><div class="line"><a class="code" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">sigc::mem_fun</a>(mysignal, &<a class="code" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42">sigc::signal1::emit</a>)</div>
+<div class="ttc" id="aclasssigc_1_1signal1_html_affe595f8b70b4f43a21be7192c0cba42"><div class="ttname"><a href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42">sigc::signal1::emit</a></div><div class="ttdeci">result_type emit(type_trait_take_t< T_arg1 > _A_a1) const</div><div class="ttdoc">Triggers the emission of the signal.</div><div class="ttdef"><b>Definition:</b> signal.h:2950</div></div>
+<div class="ttc" id="agroup__mem__fun_html_gadf6b6d22c503b439019f0a2e77352419"><div class="ttname"><a href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">sigc::mem_fun</a></div><div class="ttdeci">mem_functor0< T_return, T_obj > mem_fun(T_return(T_obj::*_A_func)())</div><div class="ttdoc">Creates a functor of type sigc::mem_functor0 which wraps a method.</div><div class="ttdef"><b>Definition:</b> mem_fun.h:5797</div></div>
+</div><!-- fragment --><p> yields the same result. </p><dl class="section return"><dt>Returns</dt><dd>A functor that calls <a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42" title="Triggers the emission of the signal.">emit()</a> on this signal. </dd></dl>
+
+</div>
+</div>
+<a id="a828907c11f5c18d9522e5d5139484620"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a828907c11f5c18d9522e5d5139484620">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a> <a class="el" href="classsigc_1_1signal1.html">sigc::signal1</a>< T_return, T_arg1, T_accumulator >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42" title="Triggers the emission of the signal.">emit()</a>). </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000038">Deprecated:</a></b></dt><dd>This is apparently not useful, but let us know if you need it. </dd></dl>
+
+</div>
+</div>
+<a id="a29cd06bf91f96f11c5f29237b8afbb71"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a29cd06bf91f96f11c5f29237b8afbb71">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal1.html">signal1</a>& <a class="el" href="classsigc_1_1signal1.html">sigc::signal1</a>< T_return, T_arg1, T_accumulator >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal1.html">signal1</a>< T_return, T_arg1, T_accumulator > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ab817711d4bc93402d15e87b89a09c364"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab817711d4bc93402d15e87b89a09c364">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal1.html">signal1</a>& <a class="el" href="classsigc_1_1signal1.html">sigc::signal1</a>< T_return, T_arg1, T_accumulator >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal1.html">signal1</a>< T_return, T_arg1, T_accumulator > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a7653b68e6a3b8445de91f89060bf2600"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7653b68e6a3b8445de91f89060bf2600">◆ </a></span>slots() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal1.html#a5fadeb350140d6aaf560b217e7e7c4b4">slot_list_type</a> <a class="el" href="classsigc_1_1signal1.html">sigc::signal1</a>< T_return, T_arg1, T_accumulator >::slots </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an STL-style interface for the signal's list of slots. </p>
+<p>This interface supports iteration, insertion and removal of slots. </p><dl class="section return"><dt>Returns</dt><dd>An STL-style interface for the signal's list of slots.</dd></dl>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000039">Deprecated:</a></b></dt><dd>This is apparently not useful, but please let us know if you need it. </dd></dl>
+
+</div>
+</div>
+<a id="a7777660b21fef2a6941c7dff23964604"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7777660b21fef2a6941c7dff23964604">◆ </a></span>slots() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">const <a class="el" href="classsigc_1_1signal1.html#a5fadeb350140d6aaf560b217e7e7c4b4">slot_list_type</a> <a class="el" href="classsigc_1_1signal1.html">sigc::signal1</a>< T_return, T_arg1, T_accumulator >::slots </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an STL-style interface for the signal's list of slots. </p>
+<p>This interface supports iteration, insertion and removal of slots. </p><dl class="section return"><dt>Returns</dt><dd>An STL-style interface for the signal's list of slots.</dd></dl>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000040">Deprecated:</a></b></dt><dd>This is apparently not useful, but please let us know if you need it. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal1< T_return, T_arg1, T_accumulator >" name="sigc::signal1< T_return, T_arg1, T_accumulator >">
+<area shape="rect" id="node1" title="Signal declaration." alt="" coords="5,155,195,196"/>
+<area shape="rect" id="node2" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="33,80,167,107"/>
+<area shape="rect" id="node3" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="42,5,158,32"/>
+</map>
--- /dev/null
+188ceec6300ba81151d262de13fa5f28
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal2.html">signal2</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#aa686af4f961b098a23d4f7276437c2b0">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#ab89b1876c69ea40954b0af37e75a21b4">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#ad507bc5ea29adb2305f8fa91acbd30ee">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#aacb8fe57ffe01dea5c5fb5af44634287">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#ad2d5f3169ba147de8d43fde9e93bac98">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a01379d580d21de8bc8d0d2d62e6324ea">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a658ba1c6468882c9b1d480be2bbaf55e">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a844d15c61c83933575e7953b29365efa">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#ac8b73c0624273b8dae819255961ea6a3">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#abeb05d9a2b40882bad753fccad6522be">operator=</a>(const signal2 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a5d3f71fb9ee8754c4640fb5bfb954151">operator=</a>(signal2 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a6710759bdeb8e626fc09d8c448e6613f">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a47aba9b19bc2bef0be7183022567e3ea">signal2</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#aa634515507f2ea4a35584e12e2dc92e7">signal2</a>(const signal2 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a20c59f06175d4c48394c65035d2c3376">signal2</a>(signal2 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#af31262f54dfb2a97540de9c4a1fc5726">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#ac28b0205aa1e60cc5ce062d4d8545323">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#aa6be4804147afd56657abf5b4cf8ce3d">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal2.html">signal2</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal2-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator > Class Template Reference<div class="ingroups"><a class="el" href="group__signal.html">Signals</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Signal declaration.
+ <a href="classsigc_1_1signal2.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal2__inherit__graph.png" border="0" usemap="#asigc_1_1signal2_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__accumulator_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal2_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__accumulator_01_4_inherit__map" id="asigc_1_1signal2_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__accumulator_01_4_inherit__map">
+<area shape="rect" title="Signal declaration." alt="" coords="5,155,247,196"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="59,80,193,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="68,5,184,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:ad507bc5ea29adb2305f8fa91acbd30ee"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#ad507bc5ea29adb2305f8fa91acbd30ee">const_iterator</a></td></tr>
+<tr class="separator:ad507bc5ea29adb2305f8fa91acbd30ee"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aacb8fe57ffe01dea5c5fb5af44634287"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#aacb8fe57ffe01dea5c5fb5af44634287">const_reverse_iterator</a></td></tr>
+<tr class="separator:aacb8fe57ffe01dea5c5fb5af44634287"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a01379d580d21de8bc8d0d2d62e6324ea"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit2< T_return, T_arg1, T_arg2, T_accumulator > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a01379d580d21de8bc8d0d2d62e6324ea">emitter_type</a></td></tr>
+<tr class="separator:a01379d580d21de8bc8d0d2d62e6324ea"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a658ba1c6468882c9b1d480be2bbaf55e"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a658ba1c6468882c9b1d480be2bbaf55e">iterator</a></td></tr>
+<tr class="separator:a658ba1c6468882c9b1d480be2bbaf55e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a55151695417c33540357ff524bfe2665"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a></td></tr>
+<tr class="separator:a55151695417c33540357ff524bfe2665"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a6710759bdeb8e626fc09d8c448e6613f"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a6710759bdeb8e626fc09d8c448e6613f">reverse_iterator</a></td></tr>
+<tr class="separator:a6710759bdeb8e626fc09d8c448e6613f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af31262f54dfb2a97540de9c4a1fc5726"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#af31262f54dfb2a97540de9c4a1fc5726">slot_list_type</a></td></tr>
+<tr class="separator:af31262f54dfb2a97540de9c4a1fc5726"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af7797ae10e76307f8d230588e760f119"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a></td></tr>
+<tr class="separator:af7797ae10e76307f8d230588e760f119"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a47aba9b19bc2bef0be7183022567e3ea"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a47aba9b19bc2bef0be7183022567e3ea">signal2</a> ()</td></tr>
+<tr class="separator:a47aba9b19bc2bef0be7183022567e3ea"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa634515507f2ea4a35584e12e2dc92e7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#aa634515507f2ea4a35584e12e2dc92e7">signal2</a> (const <a class="el" href="classsigc_1_1signal2.html">signal2</a> & src)</td></tr>
+<tr class="separator:aa634515507f2ea4a35584e12e2dc92e7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a20c59f06175d4c48394c65035d2c3376"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a20c59f06175d4c48394c65035d2c3376">signal2</a> (<a class="el" href="classsigc_1_1signal2.html">signal2</a> && src)</td></tr>
+<tr class="separator:a20c59f06175d4c48394c65035d2c3376"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa686af4f961b098a23d4f7276437c2b0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#a658ba1c6468882c9b1d480be2bbaf55e">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#aa686af4f961b098a23d4f7276437c2b0">connect</a> (const <a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:aa686af4f961b098a23d4f7276437c2b0"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal2.html#aa686af4f961b098a23d4f7276437c2b0">More...</a><br /></td></tr>
+<tr class="separator:aa686af4f961b098a23d4f7276437c2b0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab89b1876c69ea40954b0af37e75a21b4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#a658ba1c6468882c9b1d480be2bbaf55e">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#ab89b1876c69ea40954b0af37e75a21b4">connect</a> (<a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:ab89b1876c69ea40954b0af37e75a21b4"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal2.html#ab89b1876c69ea40954b0af37e75a21b4">More...</a><br /></td></tr>
+<tr class="separator:ab89b1876c69ea40954b0af37e75a21b4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afd12e2a266a6399cc32e888d6f5e6f2f"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:afd12e2a266a6399cc32e888d6f5e6f2f"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f">More...</a><br /></td></tr>
+<tr class="separator:afd12e2a266a6399cc32e888d6f5e6f2f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad2d5f3169ba147de8d43fde9e93bac98"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#ad2d5f3169ba147de8d43fde9e93bac98">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:ad2d5f3169ba147de8d43fde9e93bac98"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal2.html#ad2d5f3169ba147de8d43fde9e93bac98">More...</a><br /></td></tr>
+<tr class="separator:ad2d5f3169ba147de8d43fde9e93bac98"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a844d15c61c83933575e7953b29365efa"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html">bound_const_mem_functor2</a>< <a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a>, <a class="el" href="classsigc_1_1signal2.html">signal2</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a844d15c61c83933575e7953b29365efa">make_slot</a> () const</td></tr>
+<tr class="memdesc:a844d15c61c83933575e7953b29365efa"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal2.html#a844d15c61c83933575e7953b29365efa">More...</a><br /></td></tr>
+<tr class="separator:a844d15c61c83933575e7953b29365efa"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8b73c0624273b8dae819255961ea6a3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#ac8b73c0624273b8dae819255961ea6a3">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:ac8b73c0624273b8dae819255961ea6a3"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal2.html#ac8b73c0624273b8dae819255961ea6a3">More...</a><br /></td></tr>
+<tr class="separator:ac8b73c0624273b8dae819255961ea6a3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abeb05d9a2b40882bad753fccad6522be"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html">signal2</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#abeb05d9a2b40882bad753fccad6522be">operator=</a> (const <a class="el" href="classsigc_1_1signal2.html">signal2</a> & src)</td></tr>
+<tr class="separator:abeb05d9a2b40882bad753fccad6522be"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5d3f71fb9ee8754c4640fb5bfb954151"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html">signal2</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a5d3f71fb9ee8754c4640fb5bfb954151">operator=</a> (<a class="el" href="classsigc_1_1signal2.html">signal2</a> && src)</td></tr>
+<tr class="separator:a5d3f71fb9ee8754c4640fb5bfb954151"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac28b0205aa1e60cc5ce062d4d8545323"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#af31262f54dfb2a97540de9c4a1fc5726">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#ac28b0205aa1e60cc5ce062d4d8545323">slots</a> ()</td></tr>
+<tr class="memdesc:ac28b0205aa1e60cc5ce062d4d8545323"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal2.html#ac28b0205aa1e60cc5ce062d4d8545323">More...</a><br /></td></tr>
+<tr class="separator:ac28b0205aa1e60cc5ce062d4d8545323"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa6be4804147afd56657abf5b4cf8ce3d"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal2.html#af31262f54dfb2a97540de9c4a1fc5726">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#aa6be4804147afd56657abf5b4cf8ce3d">slots</a> () const</td></tr>
+<tr class="memdesc:aa6be4804147afd56657abf5b4cf8ce3d"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal2.html#aa6be4804147afd56657abf5b4cf8ce3d">More...</a><br /></td></tr>
+<tr class="separator:aa6be4804147afd56657abf5b4cf8ce3d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_accumulator = nil><br />
+class sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></h3>
+
+<p>Signal declaration. </p>
+<p><a class="el" href="classsigc_1_1signal2.html" title="Signal declaration.">signal2</a> can be used to <a class="el" href="classsigc_1_1signal2.html#aa686af4f961b098a23d4f7276437c2b0" title="Add a slot to the list of slots.">connect()</a> slots that are invoked during subsequent calls to <a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f" title="Triggers the emission of the signal.">emit()</a>. Any functor or slot can be passed into <a class="el" href="classsigc_1_1signal2.html#aa686af4f961b098a23d4f7276437c2b0" title="Add a slot to the list of slots.">connect()</a>. It is converted into a slot implicitly.</p>
+<p>If you want to connect one signal to another, use <a class="el" href="classsigc_1_1signal2.html#a844d15c61c83933575e7953b29365efa" title="Creates a functor that calls emit() on this signal.">make_slot()</a> to retrieve a functor that emits the signal when invoked.</p>
+<p>Be careful if you directly pass one signal into the <a class="el" href="classsigc_1_1signal2.html#aa686af4f961b098a23d4f7276437c2b0" title="Add a slot to the list of slots.">connect()</a> 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.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_return</em> The desired return type for the <a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f" title="Triggers the emission of the signal.">emit()</a> function (may be overridden by the accumulator).</li>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f" title="Triggers the emission of the signal.">emit()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f" title="Triggers the emission of the signal.">emit()</a>.</li>
+<li><em>T_accumulator</em> The accumulator type used for emission. The default <code>nil</code> means that no accumulator should be used, for example if signal emission returns the return value of the last slot invoked.</li>
+</ul>
+<p>You should use the more convenient unnumbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> template. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="ad507bc5ea29adb2305f8fa91acbd30ee"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad507bc5ea29adb2305f8fa91acbd30ee">◆ </a></span>const_iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> <a class="el" href="classsigc_1_1signal2.html">sigc::signal2</a>< T_return, T_arg1, T_arg2, T_accumulator >::<a class="el" href="classsigc_1_1signal2.html#ad507bc5ea29adb2305f8fa91acbd30ee">const_iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aacb8fe57ffe01dea5c5fb5af44634287"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aacb8fe57ffe01dea5c5fb5af44634287">◆ </a></span>const_reverse_iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> <a class="el" href="classsigc_1_1signal2.html">sigc::signal2</a>< T_return, T_arg1, T_arg2, T_accumulator >::<a class="el" href="classsigc_1_1signal2.html#aacb8fe57ffe01dea5c5fb5af44634287">const_reverse_iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a01379d580d21de8bc8d0d2d62e6324ea"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a01379d580d21de8bc8d0d2d62e6324ea">◆ </a></span>emitter_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef internal::signal_emit2<T_return, T_arg1, T_arg2, T_accumulator> <a class="el" href="classsigc_1_1signal2.html">sigc::signal2</a>< T_return, T_arg1, T_arg2, T_accumulator >::<a class="el" href="classsigc_1_1signal2.html#a01379d580d21de8bc8d0d2d62e6324ea">emitter_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a658ba1c6468882c9b1d480be2bbaf55e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a658ba1c6468882c9b1d480be2bbaf55e">◆ </a></span>iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> <a class="el" href="classsigc_1_1signal2.html">sigc::signal2</a>< T_return, T_arg1, T_arg2, T_accumulator >::<a class="el" href="classsigc_1_1signal2.html#a658ba1c6468882c9b1d480be2bbaf55e">iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a55151695417c33540357ff524bfe2665"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a55151695417c33540357ff524bfe2665">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef emitter_type::result_type <a class="el" href="classsigc_1_1signal2.html">sigc::signal2</a>< T_return, T_arg1, T_arg2, T_accumulator >::<a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a6710759bdeb8e626fc09d8c448e6613f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a6710759bdeb8e626fc09d8c448e6613f">◆ </a></span>reverse_iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> <a class="el" href="classsigc_1_1signal2.html">sigc::signal2</a>< T_return, T_arg1, T_arg2, T_accumulator >::<a class="el" href="classsigc_1_1signal2.html#a6710759bdeb8e626fc09d8c448e6613f">reverse_iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="af31262f54dfb2a97540de9c4a1fc5726"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af31262f54dfb2a97540de9c4a1fc5726">◆ </a></span>slot_list_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a><<a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a>> <a class="el" href="classsigc_1_1signal2.html">sigc::signal2</a>< T_return, T_arg1, T_arg2, T_accumulator >::<a class="el" href="classsigc_1_1signal2.html#af31262f54dfb2a97540de9c4a1fc5726">slot_list_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="af7797ae10e76307f8d230588e760f119"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af7797ae10e76307f8d230588e760f119">◆ </a></span>slot_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="classsigc_1_1slot.html">slot</a><T_return(T_arg1, T_arg2)> <a class="el" href="classsigc_1_1signal2.html">sigc::signal2</a>< T_return, T_arg1, T_arg2, T_accumulator >::<a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a47aba9b19bc2bef0be7183022567e3ea"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a47aba9b19bc2bef0be7183022567e3ea">◆ </a></span>signal2() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2</a>< T_return, T_arg1, T_arg2, T_accumulator >::<a class="el" href="classsigc_1_1signal2.html">signal2</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aa634515507f2ea4a35584e12e2dc92e7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa634515507f2ea4a35584e12e2dc92e7">◆ </a></span>signal2() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2</a>< T_return, T_arg1, T_arg2, T_accumulator >::<a class="el" href="classsigc_1_1signal2.html">signal2</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal2.html">signal2</a>< T_return, T_arg1, T_arg2, T_accumulator > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a20c59f06175d4c48394c65035d2c3376"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a20c59f06175d4c48394c65035d2c3376">◆ </a></span>signal2() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2</a>< T_return, T_arg1, T_arg2, T_accumulator >::<a class="el" href="classsigc_1_1signal2.html">signal2</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal2.html">signal2</a>< T_return, T_arg1, T_arg2, T_accumulator > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="aa686af4f961b098a23d4f7276437c2b0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa686af4f961b098a23d4f7276437c2b0">◆ </a></span>connect() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal2.html#a658ba1c6468882c9b1d480be2bbaf55e">iterator</a> <a class="el" href="classsigc_1_1signal2.html">sigc::signal2</a>< T_return, T_arg1, T_arg2, T_accumulator >::connect </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a> & </td>
+ <td class="paramname"><em>slot_</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Add a slot to the list of slots. </p>
+<p>Any functor or slot may be passed into <a class="el" href="classsigc_1_1signal2.html#aa686af4f961b098a23d4f7276437c2b0" title="Add a slot to the list of slots.">connect()</a>. 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 <a class="el" href="structsigc_1_1connection.html" title="Convinience class for safe disconnection.">sigc::connection</a> object that may be used safely beyond the life time of the slot.</p>
+<p>std::function<> and C++11 lambda expressions are functors. These are examples of functors that can be connected to a signal.</p>
+<p>std::bind() creates a functor, but this functor typically has an operator()() which is a variadic template. Our <a class="el" href="structsigc_1_1functor__trait.html" title="Trait that specifies the return type of any type.">functor_trait</a> 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.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">slot_</td><td>The slot to add to the list of slots. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>An iterator pointing to the new slot in the list. </dd></dl>
+
+</div>
+</div>
+<a id="ab89b1876c69ea40954b0af37e75a21b4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab89b1876c69ea40954b0af37e75a21b4">◆ </a></span>connect() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal2.html#a658ba1c6468882c9b1d480be2bbaf55e">iterator</a> <a class="el" href="classsigc_1_1signal2.html">sigc::signal2</a>< T_return, T_arg1, T_arg2, T_accumulator >::connect </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a> && </td>
+ <td class="paramname"><em>slot_</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Add a slot to the list of slots. </p>
+<dl class="section see"><dt>See also</dt><dd><a class="el" href="classsigc_1_1signal2.html#aa686af4f961b098a23d4f7276437c2b0" title="Add a slot to the list of slots.">connect(const slot_type& slot_)</a>.</dd></dl>
+<dl class="since_2_8"><dt><b><a class="el" href="since_2_8.html#_since_2_8000003">Since libsigc++ 2.8:</a></b></dt><dd></dd></dl>
+
+</div>
+</div>
+<a id="afd12e2a266a6399cc32e888d6f5e6f2f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#afd12e2a266a6399cc32e888d6f5e6f2f">◆ </a></span>emit()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a> <a class="el" href="classsigc_1_1signal2.html">sigc::signal2</a>< T_return, T_arg1, T_arg2, T_accumulator >::emit </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Triggers the emission of the signal. </p>
+<p>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 <em>T_accumulated</em> is not <code>nil</code>, 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. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the slots. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the slots. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The accumulated return values of the slot invocations. </dd></dl>
+
+</div>
+</div>
+<a id="ad2d5f3169ba147de8d43fde9e93bac98"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad2d5f3169ba147de8d43fde9e93bac98">◆ </a></span>emit_reverse()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a> <a class="el" href="classsigc_1_1signal2.html">sigc::signal2</a>< T_return, T_arg1, T_arg2, T_accumulator >::emit_reverse </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f" title="Triggers the emission of the signal.">emit()</a>). </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000041">Deprecated:</a></b></dt><dd>This is apparently not useful, but please let us know if you need it. </dd></dl>
+
+</div>
+</div>
+<a id="a844d15c61c83933575e7953b29365efa"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a844d15c61c83933575e7953b29365efa">◆ </a></span>make_slot()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html">bound_const_mem_functor2</a><<a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a>, <a class="el" href="classsigc_1_1signal2.html">signal2</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg1>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg2> > <a class="el" href="classsigc_1_1signal2.html">sigc::signal2</a>< T_return, T_arg1, T_arg2, T_accumulator >::make_slot </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor that calls <a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f" title="Triggers the emission of the signal.">emit()</a> on this signal. </p>
+<div class="fragment"><div class="line"><a class="code" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">sigc::mem_fun</a>(mysignal, &<a class="code" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f">sigc::signal2::emit</a>)</div>
+<div class="ttc" id="aclasssigc_1_1signal2_html_afd12e2a266a6399cc32e888d6f5e6f2f"><div class="ttname"><a href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f">sigc::signal2::emit</a></div><div class="ttdeci">result_type emit(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</div><div class="ttdoc">Triggers the emission of the signal.</div><div class="ttdef"><b>Definition:</b> signal.h:3103</div></div>
+<div class="ttc" id="agroup__mem__fun_html_gadf6b6d22c503b439019f0a2e77352419"><div class="ttname"><a href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">sigc::mem_fun</a></div><div class="ttdeci">mem_functor0< T_return, T_obj > mem_fun(T_return(T_obj::*_A_func)())</div><div class="ttdoc">Creates a functor of type sigc::mem_functor0 which wraps a method.</div><div class="ttdef"><b>Definition:</b> mem_fun.h:5797</div></div>
+</div><!-- fragment --><p> yields the same result. </p><dl class="section return"><dt>Returns</dt><dd>A functor that calls <a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f" title="Triggers the emission of the signal.">emit()</a> on this signal. </dd></dl>
+
+</div>
+</div>
+<a id="ac8b73c0624273b8dae819255961ea6a3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac8b73c0624273b8dae819255961ea6a3">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a> <a class="el" href="classsigc_1_1signal2.html">sigc::signal2</a>< T_return, T_arg1, T_arg2, T_accumulator >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f" title="Triggers the emission of the signal.">emit()</a>). </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000042">Deprecated:</a></b></dt><dd>This is apparently not useful, but let us know if you need it. </dd></dl>
+
+</div>
+</div>
+<a id="abeb05d9a2b40882bad753fccad6522be"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abeb05d9a2b40882bad753fccad6522be">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal2.html">signal2</a>& <a class="el" href="classsigc_1_1signal2.html">sigc::signal2</a>< T_return, T_arg1, T_arg2, T_accumulator >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal2.html">signal2</a>< T_return, T_arg1, T_arg2, T_accumulator > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a5d3f71fb9ee8754c4640fb5bfb954151"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5d3f71fb9ee8754c4640fb5bfb954151">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal2.html">signal2</a>& <a class="el" href="classsigc_1_1signal2.html">sigc::signal2</a>< T_return, T_arg1, T_arg2, T_accumulator >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal2.html">signal2</a>< T_return, T_arg1, T_arg2, T_accumulator > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ac28b0205aa1e60cc5ce062d4d8545323"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac28b0205aa1e60cc5ce062d4d8545323">◆ </a></span>slots() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal2.html#af31262f54dfb2a97540de9c4a1fc5726">slot_list_type</a> <a class="el" href="classsigc_1_1signal2.html">sigc::signal2</a>< T_return, T_arg1, T_arg2, T_accumulator >::slots </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an STL-style interface for the signal's list of slots. </p>
+<p>This interface supports iteration, insertion and removal of slots. </p><dl class="section return"><dt>Returns</dt><dd>An STL-style interface for the signal's list of slots.</dd></dl>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000043">Deprecated:</a></b></dt><dd>This is apparently not useful, but please let us know if you need it. </dd></dl>
+
+</div>
+</div>
+<a id="aa6be4804147afd56657abf5b4cf8ce3d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa6be4804147afd56657abf5b4cf8ce3d">◆ </a></span>slots() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">const <a class="el" href="classsigc_1_1signal2.html#af31262f54dfb2a97540de9c4a1fc5726">slot_list_type</a> <a class="el" href="classsigc_1_1signal2.html">sigc::signal2</a>< T_return, T_arg1, T_arg2, T_accumulator >::slots </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an STL-style interface for the signal's list of slots. </p>
+<p>This interface supports iteration, insertion and removal of slots. </p><dl class="section return"><dt>Returns</dt><dd>An STL-style interface for the signal's list of slots.</dd></dl>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000044">Deprecated:</a></b></dt><dd>This is apparently not useful, but please let us know if you need it. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator >" name="sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator >">
+<area shape="rect" id="node1" title="Signal declaration." alt="" coords="5,155,247,196"/>
+<area shape="rect" id="node2" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="59,80,193,107"/>
+<area shape="rect" id="node3" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="68,5,184,32"/>
+</map>
--- /dev/null
+f27f307e2d6638eedb6fe155f647935d
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal3.html">signal3</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a3eae0b3796b2736be847f33a5124aacd">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#ad71389c6d6ea60e745897579b3344d00">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a60e1ef95f82cd8981d61576d1e3f8e94">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a4ba3eb58c4c5ac2c25f49c48fd0af264">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a97ff4f22c97920a81e3f27aa5d39ba99">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#adf54ec96c5fb78d4c8b7fc032a1937ad">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a8029a48126a2018947a2b6680ddabe6b">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a332be8eb0ee22c11a2e1d140ca1bc2df">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#aa7ae5338d6a883a28c61ff202e43547f">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a0c398a25051e920bc4338f35b4bf7df6">operator=</a>(const signal3 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#abafd9fe17f2b9b18e25eb0293e9e8bfd">operator=</a>(signal3 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#acc453f0d5fc7f277494b2d6e737f6f68">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a52731959f272612fd6abfe8850c5c8cf">signal3</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#afe2c4320927b403b011a2538317e6c70">signal3</a>(const signal3 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#acd69c2a1d993f0b8993f82998f76020d">signal3</a>(signal3 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a3bc0616e7ac933e702a889a2a84e92d4">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#ab9606b708078956a758b81503f956bee">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a742eb282312187bf8ee6992df1114781">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal3.html">signal3</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal3-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator > Class Template Reference<div class="ingroups"><a class="el" href="group__signal.html">Signals</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Signal declaration.
+ <a href="classsigc_1_1signal3.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal3__inherit__graph.png" border="0" usemap="#asigc_1_1signal3_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__accumulator_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal3_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__accumulator_01_4_inherit__map" id="asigc_1_1signal3_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__accumulator_01_4_inherit__map">
+<area shape="rect" title="Signal declaration." alt="" coords="5,155,184,211"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="28,80,161,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="37,5,153,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a60e1ef95f82cd8981d61576d1e3f8e94"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a60e1ef95f82cd8981d61576d1e3f8e94">const_iterator</a></td></tr>
+<tr class="separator:a60e1ef95f82cd8981d61576d1e3f8e94"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4ba3eb58c4c5ac2c25f49c48fd0af264"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a4ba3eb58c4c5ac2c25f49c48fd0af264">const_reverse_iterator</a></td></tr>
+<tr class="separator:a4ba3eb58c4c5ac2c25f49c48fd0af264"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adf54ec96c5fb78d4c8b7fc032a1937ad"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#adf54ec96c5fb78d4c8b7fc032a1937ad">emitter_type</a></td></tr>
+<tr class="separator:adf54ec96c5fb78d4c8b7fc032a1937ad"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8029a48126a2018947a2b6680ddabe6b"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a8029a48126a2018947a2b6680ddabe6b">iterator</a></td></tr>
+<tr class="separator:a8029a48126a2018947a2b6680ddabe6b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a57c79755fc4c4b04196a9bf6742a0cc6"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a></td></tr>
+<tr class="separator:a57c79755fc4c4b04196a9bf6742a0cc6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acc453f0d5fc7f277494b2d6e737f6f68"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#acc453f0d5fc7f277494b2d6e737f6f68">reverse_iterator</a></td></tr>
+<tr class="separator:acc453f0d5fc7f277494b2d6e737f6f68"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3bc0616e7ac933e702a889a2a84e92d4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a3bc0616e7ac933e702a889a2a84e92d4">slot_list_type</a></td></tr>
+<tr class="separator:a3bc0616e7ac933e702a889a2a84e92d4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afe37478128b40fb4efedcd3c0eb05b6b"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2, T_arg3)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a></td></tr>
+<tr class="separator:afe37478128b40fb4efedcd3c0eb05b6b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a52731959f272612fd6abfe8850c5c8cf"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a52731959f272612fd6abfe8850c5c8cf">signal3</a> ()</td></tr>
+<tr class="separator:a52731959f272612fd6abfe8850c5c8cf"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afe2c4320927b403b011a2538317e6c70"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#afe2c4320927b403b011a2538317e6c70">signal3</a> (const <a class="el" href="classsigc_1_1signal3.html">signal3</a> & src)</td></tr>
+<tr class="separator:afe2c4320927b403b011a2538317e6c70"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acd69c2a1d993f0b8993f82998f76020d"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#acd69c2a1d993f0b8993f82998f76020d">signal3</a> (<a class="el" href="classsigc_1_1signal3.html">signal3</a> && src)</td></tr>
+<tr class="separator:acd69c2a1d993f0b8993f82998f76020d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3eae0b3796b2736be847f33a5124aacd"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a8029a48126a2018947a2b6680ddabe6b">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a3eae0b3796b2736be847f33a5124aacd">connect</a> (const <a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:a3eae0b3796b2736be847f33a5124aacd"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal3.html#a3eae0b3796b2736be847f33a5124aacd">More...</a><br /></td></tr>
+<tr class="separator:a3eae0b3796b2736be847f33a5124aacd"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad71389c6d6ea60e745897579b3344d00"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a8029a48126a2018947a2b6680ddabe6b">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#ad71389c6d6ea60e745897579b3344d00">connect</a> (<a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:ad71389c6d6ea60e745897579b3344d00"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal3.html#ad71389c6d6ea60e745897579b3344d00">More...</a><br /></td></tr>
+<tr class="separator:ad71389c6d6ea60e745897579b3344d00"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8592e22e3780f2cdf19a568a8a116bbb"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:a8592e22e3780f2cdf19a568a8a116bbb"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb">More...</a><br /></td></tr>
+<tr class="separator:a8592e22e3780f2cdf19a568a8a116bbb"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a97ff4f22c97920a81e3f27aa5d39ba99"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a97ff4f22c97920a81e3f27aa5d39ba99">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:a97ff4f22c97920a81e3f27aa5d39ba99"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal3.html#a97ff4f22c97920a81e3f27aa5d39ba99">More...</a><br /></td></tr>
+<tr class="separator:a97ff4f22c97920a81e3f27aa5d39ba99"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a332be8eb0ee22c11a2e1d140ca1bc2df"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html">bound_const_mem_functor3</a>< <a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a>, <a class="el" href="classsigc_1_1signal3.html">signal3</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a332be8eb0ee22c11a2e1d140ca1bc2df">make_slot</a> () const</td></tr>
+<tr class="memdesc:a332be8eb0ee22c11a2e1d140ca1bc2df"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal3.html#a332be8eb0ee22c11a2e1d140ca1bc2df">More...</a><br /></td></tr>
+<tr class="separator:a332be8eb0ee22c11a2e1d140ca1bc2df"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7ae5338d6a883a28c61ff202e43547f"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#aa7ae5338d6a883a28c61ff202e43547f">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:aa7ae5338d6a883a28c61ff202e43547f"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal3.html#aa7ae5338d6a883a28c61ff202e43547f">More...</a><br /></td></tr>
+<tr class="separator:aa7ae5338d6a883a28c61ff202e43547f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0c398a25051e920bc4338f35b4bf7df6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html">signal3</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a0c398a25051e920bc4338f35b4bf7df6">operator=</a> (const <a class="el" href="classsigc_1_1signal3.html">signal3</a> & src)</td></tr>
+<tr class="separator:a0c398a25051e920bc4338f35b4bf7df6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abafd9fe17f2b9b18e25eb0293e9e8bfd"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html">signal3</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#abafd9fe17f2b9b18e25eb0293e9e8bfd">operator=</a> (<a class="el" href="classsigc_1_1signal3.html">signal3</a> && src)</td></tr>
+<tr class="separator:abafd9fe17f2b9b18e25eb0293e9e8bfd"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab9606b708078956a758b81503f956bee"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a3bc0616e7ac933e702a889a2a84e92d4">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#ab9606b708078956a758b81503f956bee">slots</a> ()</td></tr>
+<tr class="memdesc:ab9606b708078956a758b81503f956bee"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal3.html#ab9606b708078956a758b81503f956bee">More...</a><br /></td></tr>
+<tr class="separator:ab9606b708078956a758b81503f956bee"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a742eb282312187bf8ee6992df1114781"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal3.html#a3bc0616e7ac933e702a889a2a84e92d4">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a742eb282312187bf8ee6992df1114781">slots</a> () const</td></tr>
+<tr class="memdesc:a742eb282312187bf8ee6992df1114781"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal3.html#a742eb282312187bf8ee6992df1114781">More...</a><br /></td></tr>
+<tr class="separator:a742eb282312187bf8ee6992df1114781"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_accumulator = nil><br />
+class sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></h3>
+
+<p>Signal declaration. </p>
+<p><a class="el" href="classsigc_1_1signal3.html" title="Signal declaration.">signal3</a> can be used to <a class="el" href="classsigc_1_1signal3.html#a3eae0b3796b2736be847f33a5124aacd" title="Add a slot to the list of slots.">connect()</a> slots that are invoked during subsequent calls to <a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb" title="Triggers the emission of the signal.">emit()</a>. Any functor or slot can be passed into <a class="el" href="classsigc_1_1signal3.html#a3eae0b3796b2736be847f33a5124aacd" title="Add a slot to the list of slots.">connect()</a>. It is converted into a slot implicitly.</p>
+<p>If you want to connect one signal to another, use <a class="el" href="classsigc_1_1signal3.html#a332be8eb0ee22c11a2e1d140ca1bc2df" title="Creates a functor that calls emit() on this signal.">make_slot()</a> to retrieve a functor that emits the signal when invoked.</p>
+<p>Be careful if you directly pass one signal into the <a class="el" href="classsigc_1_1signal3.html#a3eae0b3796b2736be847f33a5124aacd" title="Add a slot to the list of slots.">connect()</a> 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.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_return</em> The desired return type for the <a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb" title="Triggers the emission of the signal.">emit()</a> function (may be overridden by the accumulator).</li>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb" title="Triggers the emission of the signal.">emit()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb" title="Triggers the emission of the signal.">emit()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb" title="Triggers the emission of the signal.">emit()</a>.</li>
+<li><em>T_accumulator</em> The accumulator type used for emission. The default <code>nil</code> means that no accumulator should be used, for example if signal emission returns the return value of the last slot invoked.</li>
+</ul>
+<p>You should use the more convenient unnumbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> template. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a60e1ef95f82cd8981d61576d1e3f8e94"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a60e1ef95f82cd8981d61576d1e3f8e94">◆ </a></span>const_iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> <a class="el" href="classsigc_1_1signal3.html">sigc::signal3</a>< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::<a class="el" href="classsigc_1_1signal3.html#a60e1ef95f82cd8981d61576d1e3f8e94">const_iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a4ba3eb58c4c5ac2c25f49c48fd0af264"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4ba3eb58c4c5ac2c25f49c48fd0af264">◆ </a></span>const_reverse_iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> <a class="el" href="classsigc_1_1signal3.html">sigc::signal3</a>< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::<a class="el" href="classsigc_1_1signal3.html#a4ba3eb58c4c5ac2c25f49c48fd0af264">const_reverse_iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="adf54ec96c5fb78d4c8b7fc032a1937ad"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#adf54ec96c5fb78d4c8b7fc032a1937ad">◆ </a></span>emitter_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef internal::signal_emit3<T_return, T_arg1, T_arg2, T_arg3, T_accumulator> <a class="el" href="classsigc_1_1signal3.html">sigc::signal3</a>< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::<a class="el" href="classsigc_1_1signal3.html#adf54ec96c5fb78d4c8b7fc032a1937ad">emitter_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a8029a48126a2018947a2b6680ddabe6b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8029a48126a2018947a2b6680ddabe6b">◆ </a></span>iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> <a class="el" href="classsigc_1_1signal3.html">sigc::signal3</a>< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::<a class="el" href="classsigc_1_1signal3.html#a8029a48126a2018947a2b6680ddabe6b">iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a57c79755fc4c4b04196a9bf6742a0cc6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a57c79755fc4c4b04196a9bf6742a0cc6">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef emitter_type::result_type <a class="el" href="classsigc_1_1signal3.html">sigc::signal3</a>< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::<a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="acc453f0d5fc7f277494b2d6e737f6f68"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#acc453f0d5fc7f277494b2d6e737f6f68">◆ </a></span>reverse_iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> <a class="el" href="classsigc_1_1signal3.html">sigc::signal3</a>< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::<a class="el" href="classsigc_1_1signal3.html#acc453f0d5fc7f277494b2d6e737f6f68">reverse_iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a3bc0616e7ac933e702a889a2a84e92d4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3bc0616e7ac933e702a889a2a84e92d4">◆ </a></span>slot_list_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a><<a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a>> <a class="el" href="classsigc_1_1signal3.html">sigc::signal3</a>< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::<a class="el" href="classsigc_1_1signal3.html#a3bc0616e7ac933e702a889a2a84e92d4">slot_list_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="afe37478128b40fb4efedcd3c0eb05b6b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#afe37478128b40fb4efedcd3c0eb05b6b">◆ </a></span>slot_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="classsigc_1_1slot.html">slot</a><T_return(T_arg1, T_arg2, T_arg3)> <a class="el" href="classsigc_1_1signal3.html">sigc::signal3</a>< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::<a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a52731959f272612fd6abfe8850c5c8cf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a52731959f272612fd6abfe8850c5c8cf">◆ </a></span>signal3() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3</a>< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::<a class="el" href="classsigc_1_1signal3.html">signal3</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="afe2c4320927b403b011a2538317e6c70"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#afe2c4320927b403b011a2538317e6c70">◆ </a></span>signal3() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3</a>< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::<a class="el" href="classsigc_1_1signal3.html">signal3</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal3.html">signal3</a>< T_return, T_arg1, T_arg2, T_arg3, T_accumulator > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="acd69c2a1d993f0b8993f82998f76020d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#acd69c2a1d993f0b8993f82998f76020d">◆ </a></span>signal3() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3</a>< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::<a class="el" href="classsigc_1_1signal3.html">signal3</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal3.html">signal3</a>< T_return, T_arg1, T_arg2, T_arg3, T_accumulator > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a3eae0b3796b2736be847f33a5124aacd"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3eae0b3796b2736be847f33a5124aacd">◆ </a></span>connect() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal3.html#a8029a48126a2018947a2b6680ddabe6b">iterator</a> <a class="el" href="classsigc_1_1signal3.html">sigc::signal3</a>< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::connect </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a> & </td>
+ <td class="paramname"><em>slot_</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Add a slot to the list of slots. </p>
+<p>Any functor or slot may be passed into <a class="el" href="classsigc_1_1signal3.html#a3eae0b3796b2736be847f33a5124aacd" title="Add a slot to the list of slots.">connect()</a>. 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 <a class="el" href="structsigc_1_1connection.html" title="Convinience class for safe disconnection.">sigc::connection</a> object that may be used safely beyond the life time of the slot.</p>
+<p>std::function<> and C++11 lambda expressions are functors. These are examples of functors that can be connected to a signal.</p>
+<p>std::bind() creates a functor, but this functor typically has an operator()() which is a variadic template. Our <a class="el" href="structsigc_1_1functor__trait.html" title="Trait that specifies the return type of any type.">functor_trait</a> 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.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">slot_</td><td>The slot to add to the list of slots. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>An iterator pointing to the new slot in the list. </dd></dl>
+
+</div>
+</div>
+<a id="ad71389c6d6ea60e745897579b3344d00"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad71389c6d6ea60e745897579b3344d00">◆ </a></span>connect() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal3.html#a8029a48126a2018947a2b6680ddabe6b">iterator</a> <a class="el" href="classsigc_1_1signal3.html">sigc::signal3</a>< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::connect </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a> && </td>
+ <td class="paramname"><em>slot_</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Add a slot to the list of slots. </p>
+<dl class="section see"><dt>See also</dt><dd><a class="el" href="classsigc_1_1signal3.html#a3eae0b3796b2736be847f33a5124aacd" title="Add a slot to the list of slots.">connect(const slot_type& slot_)</a>.</dd></dl>
+<dl class="since_2_8"><dt><b><a class="el" href="since_2_8.html#_since_2_8000004">Since libsigc++ 2.8:</a></b></dt><dd></dd></dl>
+
+</div>
+</div>
+<a id="a8592e22e3780f2cdf19a568a8a116bbb"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8592e22e3780f2cdf19a568a8a116bbb">◆ </a></span>emit()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a> <a class="el" href="classsigc_1_1signal3.html">sigc::signal3</a>< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::emit </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Triggers the emission of the signal. </p>
+<p>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 <em>T_accumulated</em> is not <code>nil</code>, 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. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the slots. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the slots. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the slots. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The accumulated return values of the slot invocations. </dd></dl>
+
+</div>
+</div>
+<a id="a97ff4f22c97920a81e3f27aa5d39ba99"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a97ff4f22c97920a81e3f27aa5d39ba99">◆ </a></span>emit_reverse()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a> <a class="el" href="classsigc_1_1signal3.html">sigc::signal3</a>< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::emit_reverse </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb" title="Triggers the emission of the signal.">emit()</a>). </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000045">Deprecated:</a></b></dt><dd>This is apparently not useful, but please let us know if you need it. </dd></dl>
+
+</div>
+</div>
+<a id="a332be8eb0ee22c11a2e1d140ca1bc2df"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a332be8eb0ee22c11a2e1d140ca1bc2df">◆ </a></span>make_slot()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html">bound_const_mem_functor3</a><<a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a>, <a class="el" href="classsigc_1_1signal3.html">signal3</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg1>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg2>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg3> > <a class="el" href="classsigc_1_1signal3.html">sigc::signal3</a>< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::make_slot </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor that calls <a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb" title="Triggers the emission of the signal.">emit()</a> on this signal. </p>
+<div class="fragment"><div class="line"><a class="code" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">sigc::mem_fun</a>(mysignal, &<a class="code" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb">sigc::signal3::emit</a>)</div>
+<div class="ttc" id="aclasssigc_1_1signal3_html_a8592e22e3780f2cdf19a568a8a116bbb"><div class="ttname"><a href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb">sigc::signal3::emit</a></div><div class="ttdeci">result_type emit(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</div><div class="ttdoc">Triggers the emission of the signal.</div><div class="ttdef"><b>Definition:</b> signal.h:3258</div></div>
+<div class="ttc" id="agroup__mem__fun_html_gadf6b6d22c503b439019f0a2e77352419"><div class="ttname"><a href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">sigc::mem_fun</a></div><div class="ttdeci">mem_functor0< T_return, T_obj > mem_fun(T_return(T_obj::*_A_func)())</div><div class="ttdoc">Creates a functor of type sigc::mem_functor0 which wraps a method.</div><div class="ttdef"><b>Definition:</b> mem_fun.h:5797</div></div>
+</div><!-- fragment --><p> yields the same result. </p><dl class="section return"><dt>Returns</dt><dd>A functor that calls <a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb" title="Triggers the emission of the signal.">emit()</a> on this signal. </dd></dl>
+
+</div>
+</div>
+<a id="aa7ae5338d6a883a28c61ff202e43547f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa7ae5338d6a883a28c61ff202e43547f">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a> <a class="el" href="classsigc_1_1signal3.html">sigc::signal3</a>< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb" title="Triggers the emission of the signal.">emit()</a>). </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000046">Deprecated:</a></b></dt><dd>This is apparently not useful, but let us know if you need it. </dd></dl>
+
+</div>
+</div>
+<a id="a0c398a25051e920bc4338f35b4bf7df6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0c398a25051e920bc4338f35b4bf7df6">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal3.html">signal3</a>& <a class="el" href="classsigc_1_1signal3.html">sigc::signal3</a>< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal3.html">signal3</a>< T_return, T_arg1, T_arg2, T_arg3, T_accumulator > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="abafd9fe17f2b9b18e25eb0293e9e8bfd"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abafd9fe17f2b9b18e25eb0293e9e8bfd">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal3.html">signal3</a>& <a class="el" href="classsigc_1_1signal3.html">sigc::signal3</a>< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal3.html">signal3</a>< T_return, T_arg1, T_arg2, T_arg3, T_accumulator > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ab9606b708078956a758b81503f956bee"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab9606b708078956a758b81503f956bee">◆ </a></span>slots() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal3.html#a3bc0616e7ac933e702a889a2a84e92d4">slot_list_type</a> <a class="el" href="classsigc_1_1signal3.html">sigc::signal3</a>< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::slots </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an STL-style interface for the signal's list of slots. </p>
+<p>This interface supports iteration, insertion and removal of slots. </p><dl class="section return"><dt>Returns</dt><dd>An STL-style interface for the signal's list of slots.</dd></dl>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000047">Deprecated:</a></b></dt><dd>This is apparently not useful, but please let us know if you need it. </dd></dl>
+
+</div>
+</div>
+<a id="a742eb282312187bf8ee6992df1114781"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a742eb282312187bf8ee6992df1114781">◆ </a></span>slots() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">const <a class="el" href="classsigc_1_1signal3.html#a3bc0616e7ac933e702a889a2a84e92d4">slot_list_type</a> <a class="el" href="classsigc_1_1signal3.html">sigc::signal3</a>< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::slots </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an STL-style interface for the signal's list of slots. </p>
+<p>This interface supports iteration, insertion and removal of slots. </p><dl class="section return"><dt>Returns</dt><dd>An STL-style interface for the signal's list of slots.</dd></dl>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000048">Deprecated:</a></b></dt><dd>This is apparently not useful, but please let us know if you need it. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >" name="sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >">
+<area shape="rect" id="node1" title="Signal declaration." alt="" coords="5,155,184,211"/>
+<area shape="rect" id="node2" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="28,80,161,107"/>
+<area shape="rect" id="node3" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="37,5,153,32"/>
+</map>
--- /dev/null
+ba84d59de2797782c60634c1b5bde377
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal4.html">signal4</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a5fdb6df3cf74f5c96fb6319eef4d0a39">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a5c8d2d9c91a134650a52631d49ecdaac">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a3d2626edc726047c04c8fe5b9824b958">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a555ce030884fdf2bde788b75db01bedf">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a0aaf27875cdb8a0ae381372d98871ae1">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#acf3d1e6d6487c0ecc13ed3eab949eec7">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a31e8354263a3097bba9c63b8494143f0">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#aebcf1389e689b8d43ff739df118482bc">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a8523a4d47c3a6469fcc50da9977afdb8">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a05908db9c09a9c513529cd8b2106f913">operator=</a>(const signal4 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#ab21da01af7c724bf0cf9df35ee9a70c1">operator=</a>(signal4 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a1395da7d3283b0166af135193a4047c8">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a2d469f516a9edac2b20d7f6cf46e821a">signal4</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a2d29b39c12c6c014ed7166190e9c8e22">signal4</a>(const signal4 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a2197974bac2b5e8e7b1c417580686e9e">signal4</a>(signal4 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a0ad0f56a43825c6d77d36dd2f06ef828">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#ae490f1a6802c40a4c3b12e1580520c88">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a35f2cebe3804d3e04d3253b7cc8d2a72">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal4.html">signal4</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator > Class Template Reference<div class="ingroups"><a class="el" href="group__signal.html">Signals</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Signal declaration.
+ <a href="classsigc_1_1signal4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal4__inherit__graph.png" border="0" usemap="#asigc_1_1signal4_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__accumulator_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal4_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__accumulator_01_4_inherit__map" id="asigc_1_1signal4_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__accumulator_01_4_inherit__map">
+<area shape="rect" title="Signal declaration." alt="" coords="5,155,195,211"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="33,80,167,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="42,5,158,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a3d2626edc726047c04c8fe5b9824b958"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a3d2626edc726047c04c8fe5b9824b958">const_iterator</a></td></tr>
+<tr class="separator:a3d2626edc726047c04c8fe5b9824b958"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a555ce030884fdf2bde788b75db01bedf"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a555ce030884fdf2bde788b75db01bedf">const_reverse_iterator</a></td></tr>
+<tr class="separator:a555ce030884fdf2bde788b75db01bedf"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acf3d1e6d6487c0ecc13ed3eab949eec7"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#acf3d1e6d6487c0ecc13ed3eab949eec7">emitter_type</a></td></tr>
+<tr class="separator:acf3d1e6d6487c0ecc13ed3eab949eec7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a31e8354263a3097bba9c63b8494143f0"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a31e8354263a3097bba9c63b8494143f0">iterator</a></td></tr>
+<tr class="separator:a31e8354263a3097bba9c63b8494143f0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af32418ba14001a63d28af08abb7407f0"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a></td></tr>
+<tr class="separator:af32418ba14001a63d28af08abb7407f0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1395da7d3283b0166af135193a4047c8"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a1395da7d3283b0166af135193a4047c8">reverse_iterator</a></td></tr>
+<tr class="separator:a1395da7d3283b0166af135193a4047c8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0ad0f56a43825c6d77d36dd2f06ef828"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a0ad0f56a43825c6d77d36dd2f06ef828">slot_list_type</a></td></tr>
+<tr class="separator:a0ad0f56a43825c6d77d36dd2f06ef828"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa93452fe80399184444d094786be851c"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a></td></tr>
+<tr class="separator:aa93452fe80399184444d094786be851c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a2d469f516a9edac2b20d7f6cf46e821a"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a2d469f516a9edac2b20d7f6cf46e821a">signal4</a> ()</td></tr>
+<tr class="separator:a2d469f516a9edac2b20d7f6cf46e821a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2d29b39c12c6c014ed7166190e9c8e22"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a2d29b39c12c6c014ed7166190e9c8e22">signal4</a> (const <a class="el" href="classsigc_1_1signal4.html">signal4</a> & src)</td></tr>
+<tr class="separator:a2d29b39c12c6c014ed7166190e9c8e22"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2197974bac2b5e8e7b1c417580686e9e"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a2197974bac2b5e8e7b1c417580686e9e">signal4</a> (<a class="el" href="classsigc_1_1signal4.html">signal4</a> && src)</td></tr>
+<tr class="separator:a2197974bac2b5e8e7b1c417580686e9e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5fdb6df3cf74f5c96fb6319eef4d0a39"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#a31e8354263a3097bba9c63b8494143f0">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a5fdb6df3cf74f5c96fb6319eef4d0a39">connect</a> (const <a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:a5fdb6df3cf74f5c96fb6319eef4d0a39"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal4.html#a5fdb6df3cf74f5c96fb6319eef4d0a39">More...</a><br /></td></tr>
+<tr class="separator:a5fdb6df3cf74f5c96fb6319eef4d0a39"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5c8d2d9c91a134650a52631d49ecdaac"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#a31e8354263a3097bba9c63b8494143f0">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a5c8d2d9c91a134650a52631d49ecdaac">connect</a> (<a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:a5c8d2d9c91a134650a52631d49ecdaac"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal4.html#a5c8d2d9c91a134650a52631d49ecdaac">More...</a><br /></td></tr>
+<tr class="separator:a5c8d2d9c91a134650a52631d49ecdaac"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7774ba75b5e2391a6fe2841f8b3b0ef"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:aa7774ba75b5e2391a6fe2841f8b3b0ef"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef">More...</a><br /></td></tr>
+<tr class="separator:aa7774ba75b5e2391a6fe2841f8b3b0ef"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0aaf27875cdb8a0ae381372d98871ae1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a0aaf27875cdb8a0ae381372d98871ae1">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:a0aaf27875cdb8a0ae381372d98871ae1"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal4.html#a0aaf27875cdb8a0ae381372d98871ae1">More...</a><br /></td></tr>
+<tr class="separator:a0aaf27875cdb8a0ae381372d98871ae1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebcf1389e689b8d43ff739df118482bc"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html">bound_const_mem_functor4</a>< <a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a>, <a class="el" href="classsigc_1_1signal4.html">signal4</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#aebcf1389e689b8d43ff739df118482bc">make_slot</a> () const</td></tr>
+<tr class="memdesc:aebcf1389e689b8d43ff739df118482bc"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal4.html#aebcf1389e689b8d43ff739df118482bc">More...</a><br /></td></tr>
+<tr class="separator:aebcf1389e689b8d43ff739df118482bc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8523a4d47c3a6469fcc50da9977afdb8"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a8523a4d47c3a6469fcc50da9977afdb8">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:a8523a4d47c3a6469fcc50da9977afdb8"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal4.html#a8523a4d47c3a6469fcc50da9977afdb8">More...</a><br /></td></tr>
+<tr class="separator:a8523a4d47c3a6469fcc50da9977afdb8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a05908db9c09a9c513529cd8b2106f913"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html">signal4</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a05908db9c09a9c513529cd8b2106f913">operator=</a> (const <a class="el" href="classsigc_1_1signal4.html">signal4</a> & src)</td></tr>
+<tr class="separator:a05908db9c09a9c513529cd8b2106f913"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab21da01af7c724bf0cf9df35ee9a70c1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html">signal4</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#ab21da01af7c724bf0cf9df35ee9a70c1">operator=</a> (<a class="el" href="classsigc_1_1signal4.html">signal4</a> && src)</td></tr>
+<tr class="separator:ab21da01af7c724bf0cf9df35ee9a70c1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae490f1a6802c40a4c3b12e1580520c88"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#a0ad0f56a43825c6d77d36dd2f06ef828">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#ae490f1a6802c40a4c3b12e1580520c88">slots</a> ()</td></tr>
+<tr class="memdesc:ae490f1a6802c40a4c3b12e1580520c88"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal4.html#ae490f1a6802c40a4c3b12e1580520c88">More...</a><br /></td></tr>
+<tr class="separator:ae490f1a6802c40a4c3b12e1580520c88"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a35f2cebe3804d3e04d3253b7cc8d2a72"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal4.html#a0ad0f56a43825c6d77d36dd2f06ef828">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a35f2cebe3804d3e04d3253b7cc8d2a72">slots</a> () const</td></tr>
+<tr class="memdesc:a35f2cebe3804d3e04d3253b7cc8d2a72"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal4.html#a35f2cebe3804d3e04d3253b7cc8d2a72">More...</a><br /></td></tr>
+<tr class="separator:a35f2cebe3804d3e04d3253b7cc8d2a72"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_accumulator = nil><br />
+class sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></h3>
+
+<p>Signal declaration. </p>
+<p><a class="el" href="classsigc_1_1signal4.html" title="Signal declaration.">signal4</a> can be used to <a class="el" href="classsigc_1_1signal4.html#a5fdb6df3cf74f5c96fb6319eef4d0a39" title="Add a slot to the list of slots.">connect()</a> slots that are invoked during subsequent calls to <a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef" title="Triggers the emission of the signal.">emit()</a>. Any functor or slot can be passed into <a class="el" href="classsigc_1_1signal4.html#a5fdb6df3cf74f5c96fb6319eef4d0a39" title="Add a slot to the list of slots.">connect()</a>. It is converted into a slot implicitly.</p>
+<p>If you want to connect one signal to another, use <a class="el" href="classsigc_1_1signal4.html#aebcf1389e689b8d43ff739df118482bc" title="Creates a functor that calls emit() on this signal.">make_slot()</a> to retrieve a functor that emits the signal when invoked.</p>
+<p>Be careful if you directly pass one signal into the <a class="el" href="classsigc_1_1signal4.html#a5fdb6df3cf74f5c96fb6319eef4d0a39" title="Add a slot to the list of slots.">connect()</a> 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.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_return</em> The desired return type for the <a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef" title="Triggers the emission of the signal.">emit()</a> function (may be overridden by the accumulator).</li>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef" title="Triggers the emission of the signal.">emit()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef" title="Triggers the emission of the signal.">emit()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef" title="Triggers the emission of the signal.">emit()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef" title="Triggers the emission of the signal.">emit()</a>.</li>
+<li><em>T_accumulator</em> The accumulator type used for emission. The default <code>nil</code> means that no accumulator should be used, for example if signal emission returns the return value of the last slot invoked.</li>
+</ul>
+<p>You should use the more convenient unnumbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> template. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a3d2626edc726047c04c8fe5b9824b958"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3d2626edc726047c04c8fe5b9824b958">◆ </a></span>const_iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> <a class="el" href="classsigc_1_1signal4.html">sigc::signal4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::<a class="el" href="classsigc_1_1signal4.html#a3d2626edc726047c04c8fe5b9824b958">const_iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a555ce030884fdf2bde788b75db01bedf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a555ce030884fdf2bde788b75db01bedf">◆ </a></span>const_reverse_iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> <a class="el" href="classsigc_1_1signal4.html">sigc::signal4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::<a class="el" href="classsigc_1_1signal4.html#a555ce030884fdf2bde788b75db01bedf">const_reverse_iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="acf3d1e6d6487c0ecc13ed3eab949eec7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#acf3d1e6d6487c0ecc13ed3eab949eec7">◆ </a></span>emitter_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef internal::signal_emit4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator> <a class="el" href="classsigc_1_1signal4.html">sigc::signal4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::<a class="el" href="classsigc_1_1signal4.html#acf3d1e6d6487c0ecc13ed3eab949eec7">emitter_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a31e8354263a3097bba9c63b8494143f0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a31e8354263a3097bba9c63b8494143f0">◆ </a></span>iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> <a class="el" href="classsigc_1_1signal4.html">sigc::signal4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::<a class="el" href="classsigc_1_1signal4.html#a31e8354263a3097bba9c63b8494143f0">iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="af32418ba14001a63d28af08abb7407f0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af32418ba14001a63d28af08abb7407f0">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef emitter_type::result_type <a class="el" href="classsigc_1_1signal4.html">sigc::signal4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::<a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a1395da7d3283b0166af135193a4047c8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1395da7d3283b0166af135193a4047c8">◆ </a></span>reverse_iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> <a class="el" href="classsigc_1_1signal4.html">sigc::signal4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::<a class="el" href="classsigc_1_1signal4.html#a1395da7d3283b0166af135193a4047c8">reverse_iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a0ad0f56a43825c6d77d36dd2f06ef828"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0ad0f56a43825c6d77d36dd2f06ef828">◆ </a></span>slot_list_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a><<a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a>> <a class="el" href="classsigc_1_1signal4.html">sigc::signal4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::<a class="el" href="classsigc_1_1signal4.html#a0ad0f56a43825c6d77d36dd2f06ef828">slot_list_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aa93452fe80399184444d094786be851c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa93452fe80399184444d094786be851c">◆ </a></span>slot_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="classsigc_1_1slot.html">slot</a><T_return(T_arg1, T_arg2, T_arg3, T_arg4)> <a class="el" href="classsigc_1_1signal4.html">sigc::signal4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::<a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a2d469f516a9edac2b20d7f6cf46e821a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2d469f516a9edac2b20d7f6cf46e821a">◆ </a></span>signal4() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::<a class="el" href="classsigc_1_1signal4.html">signal4</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a2d29b39c12c6c014ed7166190e9c8e22"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2d29b39c12c6c014ed7166190e9c8e22">◆ </a></span>signal4() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::<a class="el" href="classsigc_1_1signal4.html">signal4</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal4.html">signal4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a2197974bac2b5e8e7b1c417580686e9e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2197974bac2b5e8e7b1c417580686e9e">◆ </a></span>signal4() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::<a class="el" href="classsigc_1_1signal4.html">signal4</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal4.html">signal4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a5fdb6df3cf74f5c96fb6319eef4d0a39"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5fdb6df3cf74f5c96fb6319eef4d0a39">◆ </a></span>connect() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal4.html#a31e8354263a3097bba9c63b8494143f0">iterator</a> <a class="el" href="classsigc_1_1signal4.html">sigc::signal4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::connect </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a> & </td>
+ <td class="paramname"><em>slot_</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Add a slot to the list of slots. </p>
+<p>Any functor or slot may be passed into <a class="el" href="classsigc_1_1signal4.html#a5fdb6df3cf74f5c96fb6319eef4d0a39" title="Add a slot to the list of slots.">connect()</a>. 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 <a class="el" href="structsigc_1_1connection.html" title="Convinience class for safe disconnection.">sigc::connection</a> object that may be used safely beyond the life time of the slot.</p>
+<p>std::function<> and C++11 lambda expressions are functors. These are examples of functors that can be connected to a signal.</p>
+<p>std::bind() creates a functor, but this functor typically has an operator()() which is a variadic template. Our <a class="el" href="structsigc_1_1functor__trait.html" title="Trait that specifies the return type of any type.">functor_trait</a> 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.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">slot_</td><td>The slot to add to the list of slots. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>An iterator pointing to the new slot in the list. </dd></dl>
+
+</div>
+</div>
+<a id="a5c8d2d9c91a134650a52631d49ecdaac"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5c8d2d9c91a134650a52631d49ecdaac">◆ </a></span>connect() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal4.html#a31e8354263a3097bba9c63b8494143f0">iterator</a> <a class="el" href="classsigc_1_1signal4.html">sigc::signal4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::connect </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a> && </td>
+ <td class="paramname"><em>slot_</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Add a slot to the list of slots. </p>
+<dl class="section see"><dt>See also</dt><dd><a class="el" href="classsigc_1_1signal4.html#a5fdb6df3cf74f5c96fb6319eef4d0a39" title="Add a slot to the list of slots.">connect(const slot_type& slot_)</a>.</dd></dl>
+<dl class="since_2_8"><dt><b><a class="el" href="since_2_8.html#_since_2_8000005">Since libsigc++ 2.8:</a></b></dt><dd></dd></dl>
+
+</div>
+</div>
+<a id="aa7774ba75b5e2391a6fe2841f8b3b0ef"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa7774ba75b5e2391a6fe2841f8b3b0ef">◆ </a></span>emit()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a> <a class="el" href="classsigc_1_1signal4.html">sigc::signal4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::emit </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Triggers the emission of the signal. </p>
+<p>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 <em>T_accumulated</em> is not <code>nil</code>, 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. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the slots. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the slots. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the slots. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the slots. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The accumulated return values of the slot invocations. </dd></dl>
+
+</div>
+</div>
+<a id="a0aaf27875cdb8a0ae381372d98871ae1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0aaf27875cdb8a0ae381372d98871ae1">◆ </a></span>emit_reverse()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a> <a class="el" href="classsigc_1_1signal4.html">sigc::signal4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::emit_reverse </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef" title="Triggers the emission of the signal.">emit()</a>). </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000049">Deprecated:</a></b></dt><dd>This is apparently not useful, but please let us know if you need it. </dd></dl>
+
+</div>
+</div>
+<a id="aebcf1389e689b8d43ff739df118482bc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aebcf1389e689b8d43ff739df118482bc">◆ </a></span>make_slot()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html">bound_const_mem_functor4</a><<a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a>, <a class="el" href="classsigc_1_1signal4.html">signal4</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg1>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg2>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg3>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg4> > <a class="el" href="classsigc_1_1signal4.html">sigc::signal4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::make_slot </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor that calls <a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef" title="Triggers the emission of the signal.">emit()</a> on this signal. </p>
+<div class="fragment"><div class="line"><a class="code" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">sigc::mem_fun</a>(mysignal, &<a class="code" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef">sigc::signal4::emit</a>)</div>
+<div class="ttc" id="aclasssigc_1_1signal4_html_aa7774ba75b5e2391a6fe2841f8b3b0ef"><div class="ttname"><a href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef">sigc::signal4::emit</a></div><div class="ttdeci">result_type emit(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</div><div class="ttdoc">Triggers the emission of the signal.</div><div class="ttdef"><b>Definition:</b> signal.h:3415</div></div>
+<div class="ttc" id="agroup__mem__fun_html_gadf6b6d22c503b439019f0a2e77352419"><div class="ttname"><a href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">sigc::mem_fun</a></div><div class="ttdeci">mem_functor0< T_return, T_obj > mem_fun(T_return(T_obj::*_A_func)())</div><div class="ttdoc">Creates a functor of type sigc::mem_functor0 which wraps a method.</div><div class="ttdef"><b>Definition:</b> mem_fun.h:5797</div></div>
+</div><!-- fragment --><p> yields the same result. </p><dl class="section return"><dt>Returns</dt><dd>A functor that calls <a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef" title="Triggers the emission of the signal.">emit()</a> on this signal. </dd></dl>
+
+</div>
+</div>
+<a id="a8523a4d47c3a6469fcc50da9977afdb8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8523a4d47c3a6469fcc50da9977afdb8">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a> <a class="el" href="classsigc_1_1signal4.html">sigc::signal4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef" title="Triggers the emission of the signal.">emit()</a>). </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000050">Deprecated:</a></b></dt><dd>This is apparently not useful, but let us know if you need it. </dd></dl>
+
+</div>
+</div>
+<a id="a05908db9c09a9c513529cd8b2106f913"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a05908db9c09a9c513529cd8b2106f913">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal4.html">signal4</a>& <a class="el" href="classsigc_1_1signal4.html">sigc::signal4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal4.html">signal4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ab21da01af7c724bf0cf9df35ee9a70c1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab21da01af7c724bf0cf9df35ee9a70c1">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal4.html">signal4</a>& <a class="el" href="classsigc_1_1signal4.html">sigc::signal4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal4.html">signal4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ae490f1a6802c40a4c3b12e1580520c88"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae490f1a6802c40a4c3b12e1580520c88">◆ </a></span>slots() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal4.html#a0ad0f56a43825c6d77d36dd2f06ef828">slot_list_type</a> <a class="el" href="classsigc_1_1signal4.html">sigc::signal4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::slots </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an STL-style interface for the signal's list of slots. </p>
+<p>This interface supports iteration, insertion and removal of slots. </p><dl class="section return"><dt>Returns</dt><dd>An STL-style interface for the signal's list of slots.</dd></dl>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000051">Deprecated:</a></b></dt><dd>This is apparently not useful, but please let us know if you need it. </dd></dl>
+
+</div>
+</div>
+<a id="a35f2cebe3804d3e04d3253b7cc8d2a72"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a35f2cebe3804d3e04d3253b7cc8d2a72">◆ </a></span>slots() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">const <a class="el" href="classsigc_1_1signal4.html#a0ad0f56a43825c6d77d36dd2f06ef828">slot_list_type</a> <a class="el" href="classsigc_1_1signal4.html">sigc::signal4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::slots </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an STL-style interface for the signal's list of slots. </p>
+<p>This interface supports iteration, insertion and removal of slots. </p><dl class="section return"><dt>Returns</dt><dd>An STL-style interface for the signal's list of slots.</dd></dl>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000052">Deprecated:</a></b></dt><dd>This is apparently not useful, but please let us know if you need it. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >" name="sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >">
+<area shape="rect" id="node1" title="Signal declaration." alt="" coords="5,155,195,211"/>
+<area shape="rect" id="node2" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="33,80,167,107"/>
+<area shape="rect" id="node3" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="42,5,158,32"/>
+</map>
--- /dev/null
+d6c418cdb05017d89ead3890f02f747f
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal5.html">signal5</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a057789cc27a920700e240f8f3d78dd65">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a05cfed3d3e29158424bc810168d78153">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a17e79eed46f178a12d2751eddcf85290">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#ad5ba46907fe236e0cff806888696d569">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#aa6d2e202263e3879f0d3949612d7fcdf">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a7d77e5fa748b024842bf92e28cf0f4ab">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#acee689b441305fcee098345729fc28f3">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a7b01481c87d4ec9c03095e76cb502c24">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a7a5bb7b92f49e99354caf50bfef16907">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a2c3d9a6d8b499da389672f44f8044ce6">operator=</a>(const signal5 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a5c652f8e549a2c555b79db8e8a05f407">operator=</a>(signal5 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#ab684cb9920d0f7949f28c03d50b58275">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#af717d1a6fd8612da84dce33fe6640b7a">signal5</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a7885861b9cdbacbe2d58a13cd96ec265">signal5</a>(const signal5 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#af39141aeec9dc870dd28926202493de4">signal5</a>(signal5 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a4c79ab227fc3b31b990e925636f7788e">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#ad6a4ae2a214d8710be6e36bb425587fc">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a32af276c9c56abbb0386f54262b40be5">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal5.html">signal5</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal5-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator > Class Template Reference<div class="ingroups"><a class="el" href="group__signal.html">Signals</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Signal declaration.
+ <a href="classsigc_1_1signal5.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal5__inherit__graph.png" border="0" usemap="#asigc_1_1signal5_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__accumulator_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal5_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__accumulator_01_4_inherit__map" id="asigc_1_1signal5_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__accumulator_01_4_inherit__map">
+<area shape="rect" title="Signal declaration." alt="" coords="5,155,247,211"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="59,80,193,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="68,5,184,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a17e79eed46f178a12d2751eddcf85290"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a17e79eed46f178a12d2751eddcf85290">const_iterator</a></td></tr>
+<tr class="separator:a17e79eed46f178a12d2751eddcf85290"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad5ba46907fe236e0cff806888696d569"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#ad5ba46907fe236e0cff806888696d569">const_reverse_iterator</a></td></tr>
+<tr class="separator:ad5ba46907fe236e0cff806888696d569"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7d77e5fa748b024842bf92e28cf0f4ab"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a7d77e5fa748b024842bf92e28cf0f4ab">emitter_type</a></td></tr>
+<tr class="separator:a7d77e5fa748b024842bf92e28cf0f4ab"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acee689b441305fcee098345729fc28f3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#acee689b441305fcee098345729fc28f3">iterator</a></td></tr>
+<tr class="separator:acee689b441305fcee098345729fc28f3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aceb959897dcf8e3c7209c283d4848b94"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a></td></tr>
+<tr class="separator:aceb959897dcf8e3c7209c283d4848b94"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab684cb9920d0f7949f28c03d50b58275"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#ab684cb9920d0f7949f28c03d50b58275">reverse_iterator</a></td></tr>
+<tr class="separator:ab684cb9920d0f7949f28c03d50b58275"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4c79ab227fc3b31b990e925636f7788e"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a4c79ab227fc3b31b990e925636f7788e">slot_list_type</a></td></tr>
+<tr class="separator:a4c79ab227fc3b31b990e925636f7788e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae73737aad5d854c6466e8b13e7963b9e"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a></td></tr>
+<tr class="separator:ae73737aad5d854c6466e8b13e7963b9e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:af717d1a6fd8612da84dce33fe6640b7a"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#af717d1a6fd8612da84dce33fe6640b7a">signal5</a> ()</td></tr>
+<tr class="separator:af717d1a6fd8612da84dce33fe6640b7a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7885861b9cdbacbe2d58a13cd96ec265"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a7885861b9cdbacbe2d58a13cd96ec265">signal5</a> (const <a class="el" href="classsigc_1_1signal5.html">signal5</a> & src)</td></tr>
+<tr class="separator:a7885861b9cdbacbe2d58a13cd96ec265"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af39141aeec9dc870dd28926202493de4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#af39141aeec9dc870dd28926202493de4">signal5</a> (<a class="el" href="classsigc_1_1signal5.html">signal5</a> && src)</td></tr>
+<tr class="separator:af39141aeec9dc870dd28926202493de4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a057789cc27a920700e240f8f3d78dd65"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#acee689b441305fcee098345729fc28f3">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a057789cc27a920700e240f8f3d78dd65">connect</a> (const <a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:a057789cc27a920700e240f8f3d78dd65"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal5.html#a057789cc27a920700e240f8f3d78dd65">More...</a><br /></td></tr>
+<tr class="separator:a057789cc27a920700e240f8f3d78dd65"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a05cfed3d3e29158424bc810168d78153"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#acee689b441305fcee098345729fc28f3">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a05cfed3d3e29158424bc810168d78153">connect</a> (<a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:a05cfed3d3e29158424bc810168d78153"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal5.html#a05cfed3d3e29158424bc810168d78153">More...</a><br /></td></tr>
+<tr class="separator:a05cfed3d3e29158424bc810168d78153"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8772fef879632c4ff45e82b4b00b0157"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:a8772fef879632c4ff45e82b4b00b0157"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157">More...</a><br /></td></tr>
+<tr class="separator:a8772fef879632c4ff45e82b4b00b0157"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa6d2e202263e3879f0d3949612d7fcdf"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#aa6d2e202263e3879f0d3949612d7fcdf">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:aa6d2e202263e3879f0d3949612d7fcdf"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal5.html#aa6d2e202263e3879f0d3949612d7fcdf">More...</a><br /></td></tr>
+<tr class="separator:aa6d2e202263e3879f0d3949612d7fcdf"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7b01481c87d4ec9c03095e76cb502c24"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html">bound_const_mem_functor5</a>< <a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a>, <a class="el" href="classsigc_1_1signal5.html">signal5</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a7b01481c87d4ec9c03095e76cb502c24">make_slot</a> () const</td></tr>
+<tr class="memdesc:a7b01481c87d4ec9c03095e76cb502c24"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal5.html#a7b01481c87d4ec9c03095e76cb502c24">More...</a><br /></td></tr>
+<tr class="separator:a7b01481c87d4ec9c03095e76cb502c24"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7a5bb7b92f49e99354caf50bfef16907"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a7a5bb7b92f49e99354caf50bfef16907">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:a7a5bb7b92f49e99354caf50bfef16907"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal5.html#a7a5bb7b92f49e99354caf50bfef16907">More...</a><br /></td></tr>
+<tr class="separator:a7a5bb7b92f49e99354caf50bfef16907"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2c3d9a6d8b499da389672f44f8044ce6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html">signal5</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a2c3d9a6d8b499da389672f44f8044ce6">operator=</a> (const <a class="el" href="classsigc_1_1signal5.html">signal5</a> & src)</td></tr>
+<tr class="separator:a2c3d9a6d8b499da389672f44f8044ce6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5c652f8e549a2c555b79db8e8a05f407"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html">signal5</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a5c652f8e549a2c555b79db8e8a05f407">operator=</a> (<a class="el" href="classsigc_1_1signal5.html">signal5</a> && src)</td></tr>
+<tr class="separator:a5c652f8e549a2c555b79db8e8a05f407"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad6a4ae2a214d8710be6e36bb425587fc"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#a4c79ab227fc3b31b990e925636f7788e">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#ad6a4ae2a214d8710be6e36bb425587fc">slots</a> ()</td></tr>
+<tr class="memdesc:ad6a4ae2a214d8710be6e36bb425587fc"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal5.html#ad6a4ae2a214d8710be6e36bb425587fc">More...</a><br /></td></tr>
+<tr class="separator:ad6a4ae2a214d8710be6e36bb425587fc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a32af276c9c56abbb0386f54262b40be5"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal5.html#a4c79ab227fc3b31b990e925636f7788e">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a32af276c9c56abbb0386f54262b40be5">slots</a> () const</td></tr>
+<tr class="memdesc:a32af276c9c56abbb0386f54262b40be5"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal5.html#a32af276c9c56abbb0386f54262b40be5">More...</a><br /></td></tr>
+<tr class="separator:a32af276c9c56abbb0386f54262b40be5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_accumulator = nil><br />
+class sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></h3>
+
+<p>Signal declaration. </p>
+<p><a class="el" href="classsigc_1_1signal5.html" title="Signal declaration.">signal5</a> can be used to <a class="el" href="classsigc_1_1signal5.html#a057789cc27a920700e240f8f3d78dd65" title="Add a slot to the list of slots.">connect()</a> slots that are invoked during subsequent calls to <a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" title="Triggers the emission of the signal.">emit()</a>. Any functor or slot can be passed into <a class="el" href="classsigc_1_1signal5.html#a057789cc27a920700e240f8f3d78dd65" title="Add a slot to the list of slots.">connect()</a>. It is converted into a slot implicitly.</p>
+<p>If you want to connect one signal to another, use <a class="el" href="classsigc_1_1signal5.html#a7b01481c87d4ec9c03095e76cb502c24" title="Creates a functor that calls emit() on this signal.">make_slot()</a> to retrieve a functor that emits the signal when invoked.</p>
+<p>Be careful if you directly pass one signal into the <a class="el" href="classsigc_1_1signal5.html#a057789cc27a920700e240f8f3d78dd65" title="Add a slot to the list of slots.">connect()</a> 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.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_return</em> The desired return type for the <a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" title="Triggers the emission of the signal.">emit()</a> function (may be overridden by the accumulator).</li>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" title="Triggers the emission of the signal.">emit()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" title="Triggers the emission of the signal.">emit()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" title="Triggers the emission of the signal.">emit()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" title="Triggers the emission of the signal.">emit()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" title="Triggers the emission of the signal.">emit()</a>.</li>
+<li><em>T_accumulator</em> The accumulator type used for emission. The default <code>nil</code> means that no accumulator should be used, for example if signal emission returns the return value of the last slot invoked.</li>
+</ul>
+<p>You should use the more convenient unnumbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> template. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a17e79eed46f178a12d2751eddcf85290"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a17e79eed46f178a12d2751eddcf85290">◆ </a></span>const_iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> <a class="el" href="classsigc_1_1signal5.html">sigc::signal5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::<a class="el" href="classsigc_1_1signal5.html#a17e79eed46f178a12d2751eddcf85290">const_iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ad5ba46907fe236e0cff806888696d569"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad5ba46907fe236e0cff806888696d569">◆ </a></span>const_reverse_iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> <a class="el" href="classsigc_1_1signal5.html">sigc::signal5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::<a class="el" href="classsigc_1_1signal5.html#ad5ba46907fe236e0cff806888696d569">const_reverse_iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a7d77e5fa748b024842bf92e28cf0f4ab"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7d77e5fa748b024842bf92e28cf0f4ab">◆ </a></span>emitter_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef internal::signal_emit5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator> <a class="el" href="classsigc_1_1signal5.html">sigc::signal5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::<a class="el" href="classsigc_1_1signal5.html#a7d77e5fa748b024842bf92e28cf0f4ab">emitter_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="acee689b441305fcee098345729fc28f3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#acee689b441305fcee098345729fc28f3">◆ </a></span>iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> <a class="el" href="classsigc_1_1signal5.html">sigc::signal5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::<a class="el" href="classsigc_1_1signal5.html#acee689b441305fcee098345729fc28f3">iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aceb959897dcf8e3c7209c283d4848b94"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aceb959897dcf8e3c7209c283d4848b94">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef emitter_type::result_type <a class="el" href="classsigc_1_1signal5.html">sigc::signal5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::<a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ab684cb9920d0f7949f28c03d50b58275"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab684cb9920d0f7949f28c03d50b58275">◆ </a></span>reverse_iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> <a class="el" href="classsigc_1_1signal5.html">sigc::signal5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::<a class="el" href="classsigc_1_1signal5.html#ab684cb9920d0f7949f28c03d50b58275">reverse_iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a4c79ab227fc3b31b990e925636f7788e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4c79ab227fc3b31b990e925636f7788e">◆ </a></span>slot_list_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a><<a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a>> <a class="el" href="classsigc_1_1signal5.html">sigc::signal5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::<a class="el" href="classsigc_1_1signal5.html#a4c79ab227fc3b31b990e925636f7788e">slot_list_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ae73737aad5d854c6466e8b13e7963b9e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae73737aad5d854c6466e8b13e7963b9e">◆ </a></span>slot_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="classsigc_1_1slot.html">slot</a><T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)> <a class="el" href="classsigc_1_1signal5.html">sigc::signal5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::<a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="af717d1a6fd8612da84dce33fe6640b7a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af717d1a6fd8612da84dce33fe6640b7a">◆ </a></span>signal5() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::<a class="el" href="classsigc_1_1signal5.html">signal5</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a7885861b9cdbacbe2d58a13cd96ec265"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7885861b9cdbacbe2d58a13cd96ec265">◆ </a></span>signal5() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::<a class="el" href="classsigc_1_1signal5.html">signal5</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal5.html">signal5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="af39141aeec9dc870dd28926202493de4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af39141aeec9dc870dd28926202493de4">◆ </a></span>signal5() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::<a class="el" href="classsigc_1_1signal5.html">signal5</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal5.html">signal5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a057789cc27a920700e240f8f3d78dd65"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a057789cc27a920700e240f8f3d78dd65">◆ </a></span>connect() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal5.html#acee689b441305fcee098345729fc28f3">iterator</a> <a class="el" href="classsigc_1_1signal5.html">sigc::signal5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::connect </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a> & </td>
+ <td class="paramname"><em>slot_</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Add a slot to the list of slots. </p>
+<p>Any functor or slot may be passed into <a class="el" href="classsigc_1_1signal5.html#a057789cc27a920700e240f8f3d78dd65" title="Add a slot to the list of slots.">connect()</a>. 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 <a class="el" href="structsigc_1_1connection.html" title="Convinience class for safe disconnection.">sigc::connection</a> object that may be used safely beyond the life time of the slot.</p>
+<p>std::function<> and C++11 lambda expressions are functors. These are examples of functors that can be connected to a signal.</p>
+<p>std::bind() creates a functor, but this functor typically has an operator()() which is a variadic template. Our <a class="el" href="structsigc_1_1functor__trait.html" title="Trait that specifies the return type of any type.">functor_trait</a> 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.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">slot_</td><td>The slot to add to the list of slots. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>An iterator pointing to the new slot in the list. </dd></dl>
+
+</div>
+</div>
+<a id="a05cfed3d3e29158424bc810168d78153"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a05cfed3d3e29158424bc810168d78153">◆ </a></span>connect() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal5.html#acee689b441305fcee098345729fc28f3">iterator</a> <a class="el" href="classsigc_1_1signal5.html">sigc::signal5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::connect </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a> && </td>
+ <td class="paramname"><em>slot_</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Add a slot to the list of slots. </p>
+<dl class="section see"><dt>See also</dt><dd><a class="el" href="classsigc_1_1signal5.html#a057789cc27a920700e240f8f3d78dd65" title="Add a slot to the list of slots.">connect(const slot_type& slot_)</a>.</dd></dl>
+<dl class="since_2_8"><dt><b><a class="el" href="since_2_8.html#_since_2_8000006">Since libsigc++ 2.8:</a></b></dt><dd></dd></dl>
+
+</div>
+</div>
+<a id="a8772fef879632c4ff45e82b4b00b0157"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8772fef879632c4ff45e82b4b00b0157">◆ </a></span>emit()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a> <a class="el" href="classsigc_1_1signal5.html">sigc::signal5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::emit </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Triggers the emission of the signal. </p>
+<p>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 <em>T_accumulated</em> is not <code>nil</code>, 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. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the slots. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the slots. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the slots. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the slots. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the slots. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The accumulated return values of the slot invocations. </dd></dl>
+
+</div>
+</div>
+<a id="aa6d2e202263e3879f0d3949612d7fcdf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa6d2e202263e3879f0d3949612d7fcdf">◆ </a></span>emit_reverse()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a> <a class="el" href="classsigc_1_1signal5.html">sigc::signal5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::emit_reverse </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" title="Triggers the emission of the signal.">emit()</a>). </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000053">Deprecated:</a></b></dt><dd>This is apparently not useful, but please let us know if you need it. </dd></dl>
+
+</div>
+</div>
+<a id="a7b01481c87d4ec9c03095e76cb502c24"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7b01481c87d4ec9c03095e76cb502c24">◆ </a></span>make_slot()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html">bound_const_mem_functor5</a><<a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a>, <a class="el" href="classsigc_1_1signal5.html">signal5</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg1>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg2>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg3>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg4>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg5> > <a class="el" href="classsigc_1_1signal5.html">sigc::signal5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::make_slot </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor that calls <a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" title="Triggers the emission of the signal.">emit()</a> on this signal. </p>
+<div class="fragment"><div class="line"><a class="code" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">sigc::mem_fun</a>(mysignal, &<a class="code" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157">sigc::signal5::emit</a>)</div>
+<div class="ttc" id="aclasssigc_1_1signal5_html_a8772fef879632c4ff45e82b4b00b0157"><div class="ttname"><a href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157">sigc::signal5::emit</a></div><div class="ttdeci">result_type emit(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</div><div class="ttdoc">Triggers the emission of the signal.</div><div class="ttdef"><b>Definition:</b> signal.h:3574</div></div>
+<div class="ttc" id="agroup__mem__fun_html_gadf6b6d22c503b439019f0a2e77352419"><div class="ttname"><a href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">sigc::mem_fun</a></div><div class="ttdeci">mem_functor0< T_return, T_obj > mem_fun(T_return(T_obj::*_A_func)())</div><div class="ttdoc">Creates a functor of type sigc::mem_functor0 which wraps a method.</div><div class="ttdef"><b>Definition:</b> mem_fun.h:5797</div></div>
+</div><!-- fragment --><p> yields the same result. </p><dl class="section return"><dt>Returns</dt><dd>A functor that calls <a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" title="Triggers the emission of the signal.">emit()</a> on this signal. </dd></dl>
+
+</div>
+</div>
+<a id="a7a5bb7b92f49e99354caf50bfef16907"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7a5bb7b92f49e99354caf50bfef16907">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a> <a class="el" href="classsigc_1_1signal5.html">sigc::signal5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" title="Triggers the emission of the signal.">emit()</a>). </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000054">Deprecated:</a></b></dt><dd>This is apparently not useful, but let us know if you need it. </dd></dl>
+
+</div>
+</div>
+<a id="a2c3d9a6d8b499da389672f44f8044ce6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2c3d9a6d8b499da389672f44f8044ce6">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal5.html">signal5</a>& <a class="el" href="classsigc_1_1signal5.html">sigc::signal5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal5.html">signal5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a5c652f8e549a2c555b79db8e8a05f407"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5c652f8e549a2c555b79db8e8a05f407">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal5.html">signal5</a>& <a class="el" href="classsigc_1_1signal5.html">sigc::signal5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal5.html">signal5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ad6a4ae2a214d8710be6e36bb425587fc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad6a4ae2a214d8710be6e36bb425587fc">◆ </a></span>slots() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal5.html#a4c79ab227fc3b31b990e925636f7788e">slot_list_type</a> <a class="el" href="classsigc_1_1signal5.html">sigc::signal5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::slots </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an STL-style interface for the signal's list of slots. </p>
+<p>This interface supports iteration, insertion and removal of slots. </p><dl class="section return"><dt>Returns</dt><dd>An STL-style interface for the signal's list of slots.</dd></dl>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000055">Deprecated:</a></b></dt><dd>This is apparently not useful, but please let us know if you need it. </dd></dl>
+
+</div>
+</div>
+<a id="a32af276c9c56abbb0386f54262b40be5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a32af276c9c56abbb0386f54262b40be5">◆ </a></span>slots() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">const <a class="el" href="classsigc_1_1signal5.html#a4c79ab227fc3b31b990e925636f7788e">slot_list_type</a> <a class="el" href="classsigc_1_1signal5.html">sigc::signal5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::slots </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an STL-style interface for the signal's list of slots. </p>
+<p>This interface supports iteration, insertion and removal of slots. </p><dl class="section return"><dt>Returns</dt><dd>An STL-style interface for the signal's list of slots.</dd></dl>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000056">Deprecated:</a></b></dt><dd>This is apparently not useful, but please let us know if you need it. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >" name="sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >">
+<area shape="rect" id="node1" title="Signal declaration." alt="" coords="5,155,247,211"/>
+<area shape="rect" id="node2" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="59,80,193,107"/>
+<area shape="rect" id="node3" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="68,5,184,32"/>
+</map>
--- /dev/null
+de55852d0752c783c307a841f180450d
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal6.html">signal6</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a66c302607cf4fb74f5d3352f9c394c9b">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a1754aa5a8959da0bb55e42864a8365af">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#ac88a9c4e9bab5ad04c66d3f5d3978f0f">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#aff490e7f75a83aa2f324a859f9071a79">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a2e8b355902f0646fb34b52b495123167">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#acdd2683223e4701f58350152f32f4488">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a1acee11287974cdac1bc63c856e5331d">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a97ae4180e80ac60b564fec58d1732317">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#affec011fd6e9605f10e50fdd4db424d8">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#ad7a4ab249b17bffccbfe441aa1420dd9">operator=</a>(const signal6 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a012b9abce888e420e1b5b3f29aa98900">operator=</a>(signal6 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a79b741b3f0def8f52fc185ad50b60673">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#af7f529bbd9cf26d468ed18426b9b51ea">signal6</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a0244dde296bd892c590c86ced5281e3b">signal6</a>(const signal6 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#ab717ce413bda79e1de41944d0675a8ca">signal6</a>(signal6 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a0e4fea9bd1ed35f9d60bbc26c4fae007">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#af44115a7bfa4586fc5312259a1df9567">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#ac66109f683ae86898ae10109a80b28a4">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal6.html">signal6</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal6-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator > Class Template Reference<div class="ingroups"><a class="el" href="group__signal.html">Signals</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Signal declaration.
+ <a href="classsigc_1_1signal6.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal6__inherit__graph.png" border="0" usemap="#asigc_1_1signal6_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__accumulator_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal6_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__accumulator_01_4_inherit__map" id="asigc_1_1signal6_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__accumulator_01_4_inherit__map">
+<area shape="rect" title="Signal declaration." alt="" coords="5,155,184,225"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="28,80,161,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="37,5,153,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:ac88a9c4e9bab5ad04c66d3f5d3978f0f"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#ac88a9c4e9bab5ad04c66d3f5d3978f0f">const_iterator</a></td></tr>
+<tr class="separator:ac88a9c4e9bab5ad04c66d3f5d3978f0f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aff490e7f75a83aa2f324a859f9071a79"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#aff490e7f75a83aa2f324a859f9071a79">const_reverse_iterator</a></td></tr>
+<tr class="separator:aff490e7f75a83aa2f324a859f9071a79"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acdd2683223e4701f58350152f32f4488"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#acdd2683223e4701f58350152f32f4488">emitter_type</a></td></tr>
+<tr class="separator:acdd2683223e4701f58350152f32f4488"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1acee11287974cdac1bc63c856e5331d"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a1acee11287974cdac1bc63c856e5331d">iterator</a></td></tr>
+<tr class="separator:a1acee11287974cdac1bc63c856e5331d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a56f1acca230e676dae665d41a10acc8f"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a></td></tr>
+<tr class="separator:a56f1acca230e676dae665d41a10acc8f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a79b741b3f0def8f52fc185ad50b60673"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a79b741b3f0def8f52fc185ad50b60673">reverse_iterator</a></td></tr>
+<tr class="separator:a79b741b3f0def8f52fc185ad50b60673"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0e4fea9bd1ed35f9d60bbc26c4fae007"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a0e4fea9bd1ed35f9d60bbc26c4fae007">slot_list_type</a></td></tr>
+<tr class="separator:a0e4fea9bd1ed35f9d60bbc26c4fae007"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac62cdf4db7dcd5e30975e51e978f03db"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a></td></tr>
+<tr class="separator:ac62cdf4db7dcd5e30975e51e978f03db"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:af7f529bbd9cf26d468ed18426b9b51ea"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#af7f529bbd9cf26d468ed18426b9b51ea">signal6</a> ()</td></tr>
+<tr class="separator:af7f529bbd9cf26d468ed18426b9b51ea"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0244dde296bd892c590c86ced5281e3b"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a0244dde296bd892c590c86ced5281e3b">signal6</a> (const <a class="el" href="classsigc_1_1signal6.html">signal6</a> & src)</td></tr>
+<tr class="separator:a0244dde296bd892c590c86ced5281e3b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab717ce413bda79e1de41944d0675a8ca"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#ab717ce413bda79e1de41944d0675a8ca">signal6</a> (<a class="el" href="classsigc_1_1signal6.html">signal6</a> && src)</td></tr>
+<tr class="separator:ab717ce413bda79e1de41944d0675a8ca"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a66c302607cf4fb74f5d3352f9c394c9b"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a1acee11287974cdac1bc63c856e5331d">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a66c302607cf4fb74f5d3352f9c394c9b">connect</a> (const <a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:a66c302607cf4fb74f5d3352f9c394c9b"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal6.html#a66c302607cf4fb74f5d3352f9c394c9b">More...</a><br /></td></tr>
+<tr class="separator:a66c302607cf4fb74f5d3352f9c394c9b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1754aa5a8959da0bb55e42864a8365af"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a1acee11287974cdac1bc63c856e5331d">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a1754aa5a8959da0bb55e42864a8365af">connect</a> (<a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:a1754aa5a8959da0bb55e42864a8365af"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal6.html#a1754aa5a8959da0bb55e42864a8365af">More...</a><br /></td></tr>
+<tr class="separator:a1754aa5a8959da0bb55e42864a8365af"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a6361a9230323e7c7e86e2c9e6c8fe21b"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:a6361a9230323e7c7e86e2c9e6c8fe21b"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b">More...</a><br /></td></tr>
+<tr class="separator:a6361a9230323e7c7e86e2c9e6c8fe21b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2e8b355902f0646fb34b52b495123167"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a2e8b355902f0646fb34b52b495123167">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:a2e8b355902f0646fb34b52b495123167"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal6.html#a2e8b355902f0646fb34b52b495123167">More...</a><br /></td></tr>
+<tr class="separator:a2e8b355902f0646fb34b52b495123167"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a97ae4180e80ac60b564fec58d1732317"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html">bound_const_mem_functor6</a>< <a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a>, <a class="el" href="classsigc_1_1signal6.html">signal6</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a97ae4180e80ac60b564fec58d1732317">make_slot</a> () const</td></tr>
+<tr class="memdesc:a97ae4180e80ac60b564fec58d1732317"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal6.html#a97ae4180e80ac60b564fec58d1732317">More...</a><br /></td></tr>
+<tr class="separator:a97ae4180e80ac60b564fec58d1732317"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:affec011fd6e9605f10e50fdd4db424d8"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#affec011fd6e9605f10e50fdd4db424d8">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:affec011fd6e9605f10e50fdd4db424d8"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal6.html#affec011fd6e9605f10e50fdd4db424d8">More...</a><br /></td></tr>
+<tr class="separator:affec011fd6e9605f10e50fdd4db424d8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad7a4ab249b17bffccbfe441aa1420dd9"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html">signal6</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#ad7a4ab249b17bffccbfe441aa1420dd9">operator=</a> (const <a class="el" href="classsigc_1_1signal6.html">signal6</a> & src)</td></tr>
+<tr class="separator:ad7a4ab249b17bffccbfe441aa1420dd9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a012b9abce888e420e1b5b3f29aa98900"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html">signal6</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a012b9abce888e420e1b5b3f29aa98900">operator=</a> (<a class="el" href="classsigc_1_1signal6.html">signal6</a> && src)</td></tr>
+<tr class="separator:a012b9abce888e420e1b5b3f29aa98900"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af44115a7bfa4586fc5312259a1df9567"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a0e4fea9bd1ed35f9d60bbc26c4fae007">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#af44115a7bfa4586fc5312259a1df9567">slots</a> ()</td></tr>
+<tr class="memdesc:af44115a7bfa4586fc5312259a1df9567"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal6.html#af44115a7bfa4586fc5312259a1df9567">More...</a><br /></td></tr>
+<tr class="separator:af44115a7bfa4586fc5312259a1df9567"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac66109f683ae86898ae10109a80b28a4"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal6.html#a0e4fea9bd1ed35f9d60bbc26c4fae007">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#ac66109f683ae86898ae10109a80b28a4">slots</a> () const</td></tr>
+<tr class="memdesc:ac66109f683ae86898ae10109a80b28a4"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal6.html#ac66109f683ae86898ae10109a80b28a4">More...</a><br /></td></tr>
+<tr class="separator:ac66109f683ae86898ae10109a80b28a4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_accumulator = nil><br />
+class sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></h3>
+
+<p>Signal declaration. </p>
+<p><a class="el" href="classsigc_1_1signal6.html" title="Signal declaration.">signal6</a> can be used to <a class="el" href="classsigc_1_1signal6.html#a66c302607cf4fb74f5d3352f9c394c9b" title="Add a slot to the list of slots.">connect()</a> slots that are invoked during subsequent calls to <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" title="Triggers the emission of the signal.">emit()</a>. Any functor or slot can be passed into <a class="el" href="classsigc_1_1signal6.html#a66c302607cf4fb74f5d3352f9c394c9b" title="Add a slot to the list of slots.">connect()</a>. It is converted into a slot implicitly.</p>
+<p>If you want to connect one signal to another, use <a class="el" href="classsigc_1_1signal6.html#a97ae4180e80ac60b564fec58d1732317" title="Creates a functor that calls emit() on this signal.">make_slot()</a> to retrieve a functor that emits the signal when invoked.</p>
+<p>Be careful if you directly pass one signal into the <a class="el" href="classsigc_1_1signal6.html#a66c302607cf4fb74f5d3352f9c394c9b" title="Add a slot to the list of slots.">connect()</a> 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.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_return</em> The desired return type for the <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" title="Triggers the emission of the signal.">emit()</a> function (may be overridden by the accumulator).</li>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" title="Triggers the emission of the signal.">emit()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" title="Triggers the emission of the signal.">emit()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" title="Triggers the emission of the signal.">emit()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" title="Triggers the emission of the signal.">emit()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" title="Triggers the emission of the signal.">emit()</a>.</li>
+<li><em>T_arg6</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" title="Triggers the emission of the signal.">emit()</a>.</li>
+<li><em>T_accumulator</em> The accumulator type used for emission. The default <code>nil</code> means that no accumulator should be used, for example if signal emission returns the return value of the last slot invoked.</li>
+</ul>
+<p>You should use the more convenient unnumbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> template. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="ac88a9c4e9bab5ad04c66d3f5d3978f0f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac88a9c4e9bab5ad04c66d3f5d3978f0f">◆ </a></span>const_iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> <a class="el" href="classsigc_1_1signal6.html">sigc::signal6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::<a class="el" href="classsigc_1_1signal6.html#ac88a9c4e9bab5ad04c66d3f5d3978f0f">const_iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aff490e7f75a83aa2f324a859f9071a79"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aff490e7f75a83aa2f324a859f9071a79">◆ </a></span>const_reverse_iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> <a class="el" href="classsigc_1_1signal6.html">sigc::signal6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::<a class="el" href="classsigc_1_1signal6.html#aff490e7f75a83aa2f324a859f9071a79">const_reverse_iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="acdd2683223e4701f58350152f32f4488"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#acdd2683223e4701f58350152f32f4488">◆ </a></span>emitter_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef internal::signal_emit6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator> <a class="el" href="classsigc_1_1signal6.html">sigc::signal6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::<a class="el" href="classsigc_1_1signal6.html#acdd2683223e4701f58350152f32f4488">emitter_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a1acee11287974cdac1bc63c856e5331d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1acee11287974cdac1bc63c856e5331d">◆ </a></span>iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> <a class="el" href="classsigc_1_1signal6.html">sigc::signal6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::<a class="el" href="classsigc_1_1signal6.html#a1acee11287974cdac1bc63c856e5331d">iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a56f1acca230e676dae665d41a10acc8f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a56f1acca230e676dae665d41a10acc8f">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef emitter_type::result_type <a class="el" href="classsigc_1_1signal6.html">sigc::signal6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::<a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a79b741b3f0def8f52fc185ad50b60673"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a79b741b3f0def8f52fc185ad50b60673">◆ </a></span>reverse_iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> <a class="el" href="classsigc_1_1signal6.html">sigc::signal6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::<a class="el" href="classsigc_1_1signal6.html#a79b741b3f0def8f52fc185ad50b60673">reverse_iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a0e4fea9bd1ed35f9d60bbc26c4fae007"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0e4fea9bd1ed35f9d60bbc26c4fae007">◆ </a></span>slot_list_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a><<a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a>> <a class="el" href="classsigc_1_1signal6.html">sigc::signal6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::<a class="el" href="classsigc_1_1signal6.html#a0e4fea9bd1ed35f9d60bbc26c4fae007">slot_list_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ac62cdf4db7dcd5e30975e51e978f03db"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac62cdf4db7dcd5e30975e51e978f03db">◆ </a></span>slot_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="classsigc_1_1slot.html">slot</a><T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)> <a class="el" href="classsigc_1_1signal6.html">sigc::signal6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::<a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="af7f529bbd9cf26d468ed18426b9b51ea"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af7f529bbd9cf26d468ed18426b9b51ea">◆ </a></span>signal6() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::<a class="el" href="classsigc_1_1signal6.html">signal6</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a0244dde296bd892c590c86ced5281e3b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0244dde296bd892c590c86ced5281e3b">◆ </a></span>signal6() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::<a class="el" href="classsigc_1_1signal6.html">signal6</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal6.html">signal6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ab717ce413bda79e1de41944d0675a8ca"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab717ce413bda79e1de41944d0675a8ca">◆ </a></span>signal6() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::<a class="el" href="classsigc_1_1signal6.html">signal6</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal6.html">signal6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a66c302607cf4fb74f5d3352f9c394c9b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a66c302607cf4fb74f5d3352f9c394c9b">◆ </a></span>connect() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal6.html#a1acee11287974cdac1bc63c856e5331d">iterator</a> <a class="el" href="classsigc_1_1signal6.html">sigc::signal6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::connect </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a> & </td>
+ <td class="paramname"><em>slot_</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Add a slot to the list of slots. </p>
+<p>Any functor or slot may be passed into <a class="el" href="classsigc_1_1signal6.html#a66c302607cf4fb74f5d3352f9c394c9b" title="Add a slot to the list of slots.">connect()</a>. 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 <a class="el" href="structsigc_1_1connection.html" title="Convinience class for safe disconnection.">sigc::connection</a> object that may be used safely beyond the life time of the slot.</p>
+<p>std::function<> and C++11 lambda expressions are functors. These are examples of functors that can be connected to a signal.</p>
+<p>std::bind() creates a functor, but this functor typically has an operator()() which is a variadic template. Our <a class="el" href="structsigc_1_1functor__trait.html" title="Trait that specifies the return type of any type.">functor_trait</a> 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.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">slot_</td><td>The slot to add to the list of slots. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>An iterator pointing to the new slot in the list. </dd></dl>
+
+</div>
+</div>
+<a id="a1754aa5a8959da0bb55e42864a8365af"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1754aa5a8959da0bb55e42864a8365af">◆ </a></span>connect() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal6.html#a1acee11287974cdac1bc63c856e5331d">iterator</a> <a class="el" href="classsigc_1_1signal6.html">sigc::signal6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::connect </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a> && </td>
+ <td class="paramname"><em>slot_</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Add a slot to the list of slots. </p>
+<dl class="section see"><dt>See also</dt><dd><a class="el" href="classsigc_1_1signal6.html#a66c302607cf4fb74f5d3352f9c394c9b" title="Add a slot to the list of slots.">connect(const slot_type& slot_)</a>.</dd></dl>
+<dl class="since_2_8"><dt><b><a class="el" href="since_2_8.html#_since_2_8000007">Since libsigc++ 2.8:</a></b></dt><dd></dd></dl>
+
+</div>
+</div>
+<a id="a6361a9230323e7c7e86e2c9e6c8fe21b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a6361a9230323e7c7e86e2c9e6c8fe21b">◆ </a></span>emit()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a> <a class="el" href="classsigc_1_1signal6.html">sigc::signal6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::emit </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Triggers the emission of the signal. </p>
+<p>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 <em>T_accumulated</em> is not <code>nil</code>, 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. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the slots. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the slots. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the slots. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the slots. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the slots. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the slots. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The accumulated return values of the slot invocations. </dd></dl>
+
+</div>
+</div>
+<a id="a2e8b355902f0646fb34b52b495123167"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2e8b355902f0646fb34b52b495123167">◆ </a></span>emit_reverse()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a> <a class="el" href="classsigc_1_1signal6.html">sigc::signal6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::emit_reverse </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" title="Triggers the emission of the signal.">emit()</a>). </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000057">Deprecated:</a></b></dt><dd>This is apparently not useful, but please let us know if you need it. </dd></dl>
+
+</div>
+</div>
+<a id="a97ae4180e80ac60b564fec58d1732317"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a97ae4180e80ac60b564fec58d1732317">◆ </a></span>make_slot()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html">bound_const_mem_functor6</a><<a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a>, <a class="el" href="classsigc_1_1signal6.html">signal6</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg1>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg2>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg3>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg4>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg5>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg6> > <a class="el" href="classsigc_1_1signal6.html">sigc::signal6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::make_slot </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor that calls <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" title="Triggers the emission of the signal.">emit()</a> on this signal. </p>
+<div class="fragment"><div class="line"><a class="code" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">sigc::mem_fun</a>(mysignal, &<a class="code" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b">sigc::signal6::emit</a>)</div>
+<div class="ttc" id="aclasssigc_1_1signal6_html_a6361a9230323e7c7e86e2c9e6c8fe21b"><div class="ttname"><a href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b">sigc::signal6::emit</a></div><div class="ttdeci">result_type emit(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</div><div class="ttdoc">Triggers the emission of the signal.</div><div class="ttdef"><b>Definition:</b> signal.h:3735</div></div>
+<div class="ttc" id="agroup__mem__fun_html_gadf6b6d22c503b439019f0a2e77352419"><div class="ttname"><a href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">sigc::mem_fun</a></div><div class="ttdeci">mem_functor0< T_return, T_obj > mem_fun(T_return(T_obj::*_A_func)())</div><div class="ttdoc">Creates a functor of type sigc::mem_functor0 which wraps a method.</div><div class="ttdef"><b>Definition:</b> mem_fun.h:5797</div></div>
+</div><!-- fragment --><p> yields the same result. </p><dl class="section return"><dt>Returns</dt><dd>A functor that calls <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" title="Triggers the emission of the signal.">emit()</a> on this signal. </dd></dl>
+
+</div>
+</div>
+<a id="affec011fd6e9605f10e50fdd4db424d8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#affec011fd6e9605f10e50fdd4db424d8">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a> <a class="el" href="classsigc_1_1signal6.html">sigc::signal6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" title="Triggers the emission of the signal.">emit()</a>). </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000058">Deprecated:</a></b></dt><dd>This is apparently not useful, but let us know if you need it. </dd></dl>
+
+</div>
+</div>
+<a id="ad7a4ab249b17bffccbfe441aa1420dd9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad7a4ab249b17bffccbfe441aa1420dd9">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal6.html">signal6</a>& <a class="el" href="classsigc_1_1signal6.html">sigc::signal6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal6.html">signal6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a012b9abce888e420e1b5b3f29aa98900"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a012b9abce888e420e1b5b3f29aa98900">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal6.html">signal6</a>& <a class="el" href="classsigc_1_1signal6.html">sigc::signal6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal6.html">signal6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="af44115a7bfa4586fc5312259a1df9567"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af44115a7bfa4586fc5312259a1df9567">◆ </a></span>slots() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal6.html#a0e4fea9bd1ed35f9d60bbc26c4fae007">slot_list_type</a> <a class="el" href="classsigc_1_1signal6.html">sigc::signal6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::slots </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an STL-style interface for the signal's list of slots. </p>
+<p>This interface supports iteration, insertion and removal of slots. </p><dl class="section return"><dt>Returns</dt><dd>An STL-style interface for the signal's list of slots.</dd></dl>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000059">Deprecated:</a></b></dt><dd>This is apparently not useful, but please let us know if you need it. </dd></dl>
+
+</div>
+</div>
+<a id="ac66109f683ae86898ae10109a80b28a4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac66109f683ae86898ae10109a80b28a4">◆ </a></span>slots() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">const <a class="el" href="classsigc_1_1signal6.html#a0e4fea9bd1ed35f9d60bbc26c4fae007">slot_list_type</a> <a class="el" href="classsigc_1_1signal6.html">sigc::signal6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::slots </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an STL-style interface for the signal's list of slots. </p>
+<p>This interface supports iteration, insertion and removal of slots. </p><dl class="section return"><dt>Returns</dt><dd>An STL-style interface for the signal's list of slots.</dd></dl>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000060">Deprecated:</a></b></dt><dd>This is apparently not useful, but please let us know if you need it. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >" name="sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >">
+<area shape="rect" id="node1" title="Signal declaration." alt="" coords="5,155,184,225"/>
+<area shape="rect" id="node2" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="28,80,161,107"/>
+<area shape="rect" id="node3" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="37,5,153,32"/>
+</map>
--- /dev/null
+e9cf319458b0bc3265d4647632026ff8
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal7.html">signal7</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a5aed4bdb8d85c3d854f01410d2d9d3a4">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a6eef6225eba66a86dd32c3f3b79845f7">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#ad1ba32ad7dae0c05a4012ada78077505">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a192581feb2dbcfc9c56692e72e91e9a8">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a7fa856e67a31c86538db7c289a6870e3">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a3f468c8b6cc55d675c75d0184bd8e38a">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#ac6fd43215c8f19082402387359330071">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#af8a93a4c8fb0b78fa6578e7dc95f5751">operator=</a>(const signal7 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#ac06938f5cb6ff60a1bd5eaa32c990eea">operator=</a>(signal7 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a59c9c9fee7a98528839df592241351a9">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#ab6d54db53a164fb459fcb342d4b45ff0">signal7</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a12d6e064d0a5c2a8c09d60a64184a823">signal7</a>(const signal7 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a5a5893dd4f97d77b7945819f5ada2aee">signal7</a>(signal7 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a68153d9079b4881352113079cd6216f7">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a42509108239296e424844df2cd330aca">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal7.html">signal7</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal7-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator > Class Template Reference<div class="ingroups"><a class="el" href="group__signal.html">Signals</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Signal declaration.
+ <a href="classsigc_1_1signal7.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal7__inherit__graph.png" border="0" usemap="#asigc_1_1signal7_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_00_01T__accumulator_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal7_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_00_01T__accumulator_01_4_inherit__map" id="asigc_1_1signal7_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_00_01T__accumulator_01_4_inherit__map">
+<area shape="rect" title="Signal declaration." alt="" coords="5,155,195,225"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="33,80,167,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="42,5,158,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a6eef6225eba66a86dd32c3f3b79845f7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a6eef6225eba66a86dd32c3f3b79845f7">const_iterator</a></td></tr>
+<tr class="separator:a6eef6225eba66a86dd32c3f3b79845f7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1ba32ad7dae0c05a4012ada78077505"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#ad1ba32ad7dae0c05a4012ada78077505">const_reverse_iterator</a></td></tr>
+<tr class="separator:ad1ba32ad7dae0c05a4012ada78077505"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7fa856e67a31c86538db7c289a6870e3"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a7fa856e67a31c86538db7c289a6870e3">emitter_type</a></td></tr>
+<tr class="separator:a7fa856e67a31c86538db7c289a6870e3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abc62e52cc684f917577a2fe3cd914d4a"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a">iterator</a></td></tr>
+<tr class="separator:abc62e52cc684f917577a2fe3cd914d4a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5a75d73a254cf91a0f3ad1cd3545e29f"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a></td></tr>
+<tr class="separator:a5a75d73a254cf91a0f3ad1cd3545e29f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a59c9c9fee7a98528839df592241351a9"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a59c9c9fee7a98528839df592241351a9">reverse_iterator</a></td></tr>
+<tr class="separator:a59c9c9fee7a98528839df592241351a9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a79686c2174ab01dc23394953955ff003"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003">slot_list_type</a></td></tr>
+<tr class="separator:a79686c2174ab01dc23394953955ff003"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a72ee8c51eea3d1ba99eb9b512dfccd81"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a></td></tr>
+<tr class="separator:a72ee8c51eea3d1ba99eb9b512dfccd81"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:ab6d54db53a164fb459fcb342d4b45ff0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#ab6d54db53a164fb459fcb342d4b45ff0">signal7</a> ()</td></tr>
+<tr class="separator:ab6d54db53a164fb459fcb342d4b45ff0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a12d6e064d0a5c2a8c09d60a64184a823"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a12d6e064d0a5c2a8c09d60a64184a823">signal7</a> (const <a class="el" href="classsigc_1_1signal7.html">signal7</a> & src)</td></tr>
+<tr class="separator:a12d6e064d0a5c2a8c09d60a64184a823"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5a5893dd4f97d77b7945819f5ada2aee"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a5a5893dd4f97d77b7945819f5ada2aee">signal7</a> (<a class="el" href="classsigc_1_1signal7.html">signal7</a> && src)</td></tr>
+<tr class="separator:a5a5893dd4f97d77b7945819f5ada2aee"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adc55ac9b0f935fd87a67904022e03cb2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">connect</a> (const <a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:adc55ac9b0f935fd87a67904022e03cb2"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">More...</a><br /></td></tr>
+<tr class="separator:adc55ac9b0f935fd87a67904022e03cb2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5aed4bdb8d85c3d854f01410d2d9d3a4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a5aed4bdb8d85c3d854f01410d2d9d3a4">connect</a> (<a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:a5aed4bdb8d85c3d854f01410d2d9d3a4"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal7.html#a5aed4bdb8d85c3d854f01410d2d9d3a4">More...</a><br /></td></tr>
+<tr class="separator:a5aed4bdb8d85c3d854f01410d2d9d3a4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aead3b0e97ed0bd95f870b1956bff83c2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:aead3b0e97ed0bd95f870b1956bff83c2"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2">More...</a><br /></td></tr>
+<tr class="separator:aead3b0e97ed0bd95f870b1956bff83c2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a192581feb2dbcfc9c56692e72e91e9a8"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a192581feb2dbcfc9c56692e72e91e9a8">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:a192581feb2dbcfc9c56692e72e91e9a8"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal7.html#a192581feb2dbcfc9c56692e72e91e9a8">More...</a><br /></td></tr>
+<tr class="separator:a192581feb2dbcfc9c56692e72e91e9a8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3f468c8b6cc55d675c75d0184bd8e38a"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html">bound_const_mem_functor7</a>< <a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a>, <a class="el" href="classsigc_1_1signal7.html">signal7</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a3f468c8b6cc55d675c75d0184bd8e38a">make_slot</a> () const</td></tr>
+<tr class="memdesc:a3f468c8b6cc55d675c75d0184bd8e38a"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal7.html#a3f468c8b6cc55d675c75d0184bd8e38a">More...</a><br /></td></tr>
+<tr class="separator:a3f468c8b6cc55d675c75d0184bd8e38a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac6fd43215c8f19082402387359330071"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#ac6fd43215c8f19082402387359330071">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:ac6fd43215c8f19082402387359330071"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal7.html#ac6fd43215c8f19082402387359330071">More...</a><br /></td></tr>
+<tr class="separator:ac6fd43215c8f19082402387359330071"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af8a93a4c8fb0b78fa6578e7dc95f5751"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html">signal7</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#af8a93a4c8fb0b78fa6578e7dc95f5751">operator=</a> (const <a class="el" href="classsigc_1_1signal7.html">signal7</a> & src)</td></tr>
+<tr class="separator:af8a93a4c8fb0b78fa6578e7dc95f5751"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac06938f5cb6ff60a1bd5eaa32c990eea"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html">signal7</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#ac06938f5cb6ff60a1bd5eaa32c990eea">operator=</a> (<a class="el" href="classsigc_1_1signal7.html">signal7</a> && src)</td></tr>
+<tr class="separator:ac06938f5cb6ff60a1bd5eaa32c990eea"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a68153d9079b4881352113079cd6216f7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a68153d9079b4881352113079cd6216f7">slots</a> ()</td></tr>
+<tr class="memdesc:a68153d9079b4881352113079cd6216f7"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal7.html#a68153d9079b4881352113079cd6216f7">More...</a><br /></td></tr>
+<tr class="separator:a68153d9079b4881352113079cd6216f7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a42509108239296e424844df2cd330aca"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a42509108239296e424844df2cd330aca">slots</a> () const</td></tr>
+<tr class="memdesc:a42509108239296e424844df2cd330aca"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal7.html#a42509108239296e424844df2cd330aca">More...</a><br /></td></tr>
+<tr class="separator:a42509108239296e424844df2cd330aca"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_accumulator = nil><br />
+class sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></h3>
+
+<p>Signal declaration. </p>
+<p><a class="el" href="classsigc_1_1signal7.html" title="Signal declaration.">signal7</a> can be used to <a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2" title="Add a slot to the list of slots.">connect()</a> slots that are invoked during subsequent calls to <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a>. Any functor or slot can be passed into <a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2" title="Add a slot to the list of slots.">connect()</a>. It is converted into a slot implicitly.</p>
+<p>If you want to connect one signal to another, use <a class="el" href="classsigc_1_1signal7.html#a3f468c8b6cc55d675c75d0184bd8e38a" title="Creates a functor that calls emit() on this signal.">make_slot()</a> to retrieve a functor that emits the signal when invoked.</p>
+<p>Be careful if you directly pass one signal into the <a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2" title="Add a slot to the list of slots.">connect()</a> 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.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_return</em> The desired return type for the <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a> function (may be overridden by the accumulator).</li>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a>.</li>
+<li><em>T_arg6</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a>.</li>
+<li><em>T_arg7</em> Argument type used in the definition of <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a>.</li>
+<li><em>T_accumulator</em> The accumulator type used for emission. The default <code>nil</code> means that no accumulator should be used, for example if signal emission returns the return value of the last slot invoked.</li>
+</ul>
+<p>You should use the more convenient unnumbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> template. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a6eef6225eba66a86dd32c3f3b79845f7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a6eef6225eba66a86dd32c3f3b79845f7">◆ </a></span>const_iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> <a class="el" href="classsigc_1_1signal7.html">sigc::signal7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::<a class="el" href="classsigc_1_1signal7.html#a6eef6225eba66a86dd32c3f3b79845f7">const_iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ad1ba32ad7dae0c05a4012ada78077505"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad1ba32ad7dae0c05a4012ada78077505">◆ </a></span>const_reverse_iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> <a class="el" href="classsigc_1_1signal7.html">sigc::signal7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::<a class="el" href="classsigc_1_1signal7.html#ad1ba32ad7dae0c05a4012ada78077505">const_reverse_iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a7fa856e67a31c86538db7c289a6870e3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7fa856e67a31c86538db7c289a6870e3">◆ </a></span>emitter_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef internal::signal_emit7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator> <a class="el" href="classsigc_1_1signal7.html">sigc::signal7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::<a class="el" href="classsigc_1_1signal7.html#a7fa856e67a31c86538db7c289a6870e3">emitter_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="abc62e52cc684f917577a2fe3cd914d4a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abc62e52cc684f917577a2fe3cd914d4a">◆ </a></span>iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> <a class="el" href="classsigc_1_1signal7.html">sigc::signal7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::<a class="el" href="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a">iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a5a75d73a254cf91a0f3ad1cd3545e29f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5a75d73a254cf91a0f3ad1cd3545e29f">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef emitter_type::result_type <a class="el" href="classsigc_1_1signal7.html">sigc::signal7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::<a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a59c9c9fee7a98528839df592241351a9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a59c9c9fee7a98528839df592241351a9">◆ </a></span>reverse_iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> <a class="el" href="classsigc_1_1signal7.html">sigc::signal7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::<a class="el" href="classsigc_1_1signal7.html#a59c9c9fee7a98528839df592241351a9">reverse_iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a79686c2174ab01dc23394953955ff003"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a79686c2174ab01dc23394953955ff003">◆ </a></span>slot_list_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a><<a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a>> <a class="el" href="classsigc_1_1signal7.html">sigc::signal7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::<a class="el" href="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003">slot_list_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a72ee8c51eea3d1ba99eb9b512dfccd81"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a72ee8c51eea3d1ba99eb9b512dfccd81">◆ </a></span>slot_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_accumulator = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="classsigc_1_1slot.html">slot</a><T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)> <a class="el" href="classsigc_1_1signal7.html">sigc::signal7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::<a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="ab6d54db53a164fb459fcb342d4b45ff0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab6d54db53a164fb459fcb342d4b45ff0">◆ </a></span>signal7() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::<a class="el" href="classsigc_1_1signal7.html">signal7</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a12d6e064d0a5c2a8c09d60a64184a823"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a12d6e064d0a5c2a8c09d60a64184a823">◆ </a></span>signal7() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::<a class="el" href="classsigc_1_1signal7.html">signal7</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal7.html">signal7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a5a5893dd4f97d77b7945819f5ada2aee"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5a5893dd4f97d77b7945819f5ada2aee">◆ </a></span>signal7() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::<a class="el" href="classsigc_1_1signal7.html">signal7</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal7.html">signal7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="adc55ac9b0f935fd87a67904022e03cb2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#adc55ac9b0f935fd87a67904022e03cb2">◆ </a></span>connect() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a">iterator</a> <a class="el" href="classsigc_1_1signal7.html">sigc::signal7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::connect </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a> & </td>
+ <td class="paramname"><em>slot_</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Add a slot to the list of slots. </p>
+<p>Any functor or slot may be passed into <a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2" title="Add a slot to the list of slots.">connect()</a>. 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 <a class="el" href="structsigc_1_1connection.html" title="Convinience class for safe disconnection.">sigc::connection</a> object that may be used safely beyond the life time of the slot.</p>
+<p>std::function<> and C++11 lambda expressions are functors. These are examples of functors that can be connected to a signal.</p>
+<p>std::bind() creates a functor, but this functor typically has an operator()() which is a variadic template. Our <a class="el" href="structsigc_1_1functor__trait.html" title="Trait that specifies the return type of any type.">functor_trait</a> 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.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">slot_</td><td>The slot to add to the list of slots. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>An iterator pointing to the new slot in the list. </dd></dl>
+
+</div>
+</div>
+<a id="a5aed4bdb8d85c3d854f01410d2d9d3a4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5aed4bdb8d85c3d854f01410d2d9d3a4">◆ </a></span>connect() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a">iterator</a> <a class="el" href="classsigc_1_1signal7.html">sigc::signal7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::connect </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a> && </td>
+ <td class="paramname"><em>slot_</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Add a slot to the list of slots. </p>
+<dl class="section see"><dt>See also</dt><dd><a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2" title="Add a slot to the list of slots.">connect(const slot_type& slot_)</a>.</dd></dl>
+<dl class="since_2_8"><dt><b><a class="el" href="since_2_8.html#_since_2_8000008">Since libsigc++ 2.8:</a></b></dt><dd></dd></dl>
+
+</div>
+</div>
+<a id="aead3b0e97ed0bd95f870b1956bff83c2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aead3b0e97ed0bd95f870b1956bff83c2">◆ </a></span>emit()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> <a class="el" href="classsigc_1_1signal7.html">sigc::signal7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::emit </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > </td>
+ <td class="paramname"><em>_A_a7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Triggers the emission of the signal. </p>
+<p>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 <em>T_accumulated</em> is not <code>nil</code>, 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. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the slots. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the slots. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the slots. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the slots. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the slots. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the slots. </td></tr>
+ <tr><td class="paramname">_A_a7</td><td>Argument to be passed on to the slots. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The accumulated return values of the slot invocations. </dd></dl>
+
+</div>
+</div>
+<a id="a192581feb2dbcfc9c56692e72e91e9a8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a192581feb2dbcfc9c56692e72e91e9a8">◆ </a></span>emit_reverse()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> <a class="el" href="classsigc_1_1signal7.html">sigc::signal7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::emit_reverse </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > </td>
+ <td class="paramname"><em>_A_a7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a>). </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000061">Deprecated:</a></b></dt><dd>This is apparently not useful, but please let us know if you need it. </dd></dl>
+
+</div>
+</div>
+<a id="a3f468c8b6cc55d675c75d0184bd8e38a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3f468c8b6cc55d675c75d0184bd8e38a">◆ </a></span>make_slot()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html">bound_const_mem_functor7</a><<a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a>, <a class="el" href="classsigc_1_1signal7.html">signal7</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg1>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg2>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg3>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg4>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg5>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg6>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg7> > <a class="el" href="classsigc_1_1signal7.html">sigc::signal7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::make_slot </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor that calls <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a> on this signal. </p>
+<div class="fragment"><div class="line"><a class="code" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">sigc::mem_fun</a>(mysignal, &<a class="code" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2">sigc::signal7::emit</a>)</div>
+<div class="ttc" id="aclasssigc_1_1signal7_html_aead3b0e97ed0bd95f870b1956bff83c2"><div class="ttname"><a href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2">sigc::signal7::emit</a></div><div class="ttdeci">result_type emit(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</div><div class="ttdoc">Triggers the emission of the signal.</div><div class="ttdef"><b>Definition:</b> signal.h:3898</div></div>
+<div class="ttc" id="agroup__mem__fun_html_gadf6b6d22c503b439019f0a2e77352419"><div class="ttname"><a href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">sigc::mem_fun</a></div><div class="ttdeci">mem_functor0< T_return, T_obj > mem_fun(T_return(T_obj::*_A_func)())</div><div class="ttdoc">Creates a functor of type sigc::mem_functor0 which wraps a method.</div><div class="ttdef"><b>Definition:</b> mem_fun.h:5797</div></div>
+</div><!-- fragment --><p> yields the same result. </p><dl class="section return"><dt>Returns</dt><dd>A functor that calls <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a> on this signal. </dd></dl>
+
+</div>
+</div>
+<a id="ac6fd43215c8f19082402387359330071"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac6fd43215c8f19082402387359330071">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> <a class="el" href="classsigc_1_1signal7.html">sigc::signal7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > </td>
+ <td class="paramname"><em>_A_a7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a>). </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000062">Deprecated:</a></b></dt><dd>This is apparently not useful, but let us know if you need it. </dd></dl>
+
+</div>
+</div>
+<a id="af8a93a4c8fb0b78fa6578e7dc95f5751"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af8a93a4c8fb0b78fa6578e7dc95f5751">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal7.html">signal7</a>& <a class="el" href="classsigc_1_1signal7.html">sigc::signal7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal7.html">signal7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ac06938f5cb6ff60a1bd5eaa32c990eea"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac06938f5cb6ff60a1bd5eaa32c990eea">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal7.html">signal7</a>& <a class="el" href="classsigc_1_1signal7.html">sigc::signal7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal7.html">signal7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a68153d9079b4881352113079cd6216f7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a68153d9079b4881352113079cd6216f7">◆ </a></span>slots() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003">slot_list_type</a> <a class="el" href="classsigc_1_1signal7.html">sigc::signal7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::slots </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an STL-style interface for the signal's list of slots. </p>
+<p>This interface supports iteration, insertion and removal of slots. </p><dl class="section return"><dt>Returns</dt><dd>An STL-style interface for the signal's list of slots.</dd></dl>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000063">Deprecated:</a></b></dt><dd>This is apparently not useful, but please let us know if you need it. </dd></dl>
+
+</div>
+</div>
+<a id="a42509108239296e424844df2cd330aca"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a42509108239296e424844df2cd330aca">◆ </a></span>slots() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_accumulator = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">const <a class="el" href="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003">slot_list_type</a> <a class="el" href="classsigc_1_1signal7.html">sigc::signal7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::slots </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an STL-style interface for the signal's list of slots. </p>
+<p>This interface supports iteration, insertion and removal of slots. </p><dl class="section return"><dt>Returns</dt><dd>An STL-style interface for the signal's list of slots.</dd></dl>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000064">Deprecated:</a></b></dt><dd>This is apparently not useful, but please let us know if you need it. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >" name="sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >">
+<area shape="rect" id="node1" title="Signal declaration." alt="" coords="5,155,195,225"/>
+<area shape="rect" id="node2" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="33,80,167,107"/>
+<area shape="rect" id="node3" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="42,5,158,32"/>
+</map>
--- /dev/null
+4c1e3487d8fe31651f1a52288db29c83
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal.html">signal</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_1_1accumulated.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::accumulated< T_accumulator > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_1_1accumulated.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::accumulated< T_accumulator ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_1_1accumulated.html#a46bed3515606e0a5807f08e239891ca0">accumulated</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_1_1accumulated.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_1_1accumulated.html#a032428476a190d9dea6313f70e5b8a10">accumulated</a>(const accumulated & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_1_1accumulated.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a5aed4bdb8d85c3d854f01410d2d9d3a4">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a6eef6225eba66a86dd32c3f3b79845f7">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#ad1ba32ad7dae0c05a4012ada78077505">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a192581feb2dbcfc9c56692e72e91e9a8">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a7fa856e67a31c86538db7c289a6870e3">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a3f468c8b6cc55d675c75d0184bd8e38a">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#ac6fd43215c8f19082402387359330071">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#af8a93a4c8fb0b78fa6578e7dc95f5751">operator=</a>(const signal7 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#ac06938f5cb6ff60a1bd5eaa32c990eea">operator=</a>(signal7 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a59c9c9fee7a98528839df592241351a9">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#ab6d54db53a164fb459fcb342d4b45ff0">signal7</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a12d6e064d0a5c2a8c09d60a64184a823">signal7</a>(const signal7 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a5a5893dd4f97d77b7945819f5ada2aee">signal7</a>(signal7 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a68153d9079b4881352113079cd6216f7">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a42509108239296e424844df2cd330aca">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::accumulated< T_accumulator > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal.html">signal</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_1_1accumulated.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_1_1accumulated-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::accumulated< T_accumulator > Class Template Reference<div class="ingroups"><a class="el" href="group__signal.html">Signals</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates.
+ <a href="classsigc_1_1signal_1_1accumulated.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::accumulated< T_accumulator >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_1_1accumulated__inherit__graph.png" border="0" usemap="#asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" id="asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::signal# templates." alt="" coords="588,5,788,91"/>
+<area shape="rect" href="classsigc_1_1signal7.html" title=" " alt="" coords="351,13,540,83"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="169,35,303,61"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="5,35,121,61"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a46bed3515606e0a5807f08e239891ca0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_1_1accumulated.html#a46bed3515606e0a5807f08e239891ca0">accumulated</a> ()</td></tr>
+<tr class="separator:a46bed3515606e0a5807f08e239891ca0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a032428476a190d9dea6313f70e5b8a10"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_1_1accumulated.html#a032428476a190d9dea6313f70e5b8a10">accumulated</a> (const <a class="el" href="classsigc_1_1signal_1_1accumulated.html">accumulated</a> & src)</td></tr>
+<tr class="separator:a032428476a190d9dea6313f70e5b8a10"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal7"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal7')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td></tr>
+<tr class="memitem:ab6d54db53a164fb459fcb342d4b45ff0 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#ab6d54db53a164fb459fcb342d4b45ff0">signal7</a> ()</td></tr>
+<tr class="separator:ab6d54db53a164fb459fcb342d4b45ff0 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a12d6e064d0a5c2a8c09d60a64184a823 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a12d6e064d0a5c2a8c09d60a64184a823">signal7</a> (const <a class="el" href="classsigc_1_1signal7.html">signal7</a> & src)</td></tr>
+<tr class="separator:a12d6e064d0a5c2a8c09d60a64184a823 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5a5893dd4f97d77b7945819f5ada2aee inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a5a5893dd4f97d77b7945819f5ada2aee">signal7</a> (<a class="el" href="classsigc_1_1signal7.html">signal7</a> && src)</td></tr>
+<tr class="separator:a5a5893dd4f97d77b7945819f5ada2aee inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adc55ac9b0f935fd87a67904022e03cb2 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">connect</a> (const <a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:adc55ac9b0f935fd87a67904022e03cb2 inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">More...</a><br /></td></tr>
+<tr class="separator:adc55ac9b0f935fd87a67904022e03cb2 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5aed4bdb8d85c3d854f01410d2d9d3a4 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a5aed4bdb8d85c3d854f01410d2d9d3a4">connect</a> (<a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:a5aed4bdb8d85c3d854f01410d2d9d3a4 inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal7.html#a5aed4bdb8d85c3d854f01410d2d9d3a4">More...</a><br /></td></tr>
+<tr class="separator:a5aed4bdb8d85c3d854f01410d2d9d3a4 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aead3b0e97ed0bd95f870b1956bff83c2 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:aead3b0e97ed0bd95f870b1956bff83c2 inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2">More...</a><br /></td></tr>
+<tr class="separator:aead3b0e97ed0bd95f870b1956bff83c2 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a192581feb2dbcfc9c56692e72e91e9a8 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a192581feb2dbcfc9c56692e72e91e9a8">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:a192581feb2dbcfc9c56692e72e91e9a8 inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal7.html#a192581feb2dbcfc9c56692e72e91e9a8">More...</a><br /></td></tr>
+<tr class="separator:a192581feb2dbcfc9c56692e72e91e9a8 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3f468c8b6cc55d675c75d0184bd8e38a inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html">bound_const_mem_functor7</a>< <a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a>, <a class="el" href="classsigc_1_1signal7.html">signal7</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a3f468c8b6cc55d675c75d0184bd8e38a">make_slot</a> () const</td></tr>
+<tr class="memdesc:a3f468c8b6cc55d675c75d0184bd8e38a inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal7.html#a3f468c8b6cc55d675c75d0184bd8e38a">More...</a><br /></td></tr>
+<tr class="separator:a3f468c8b6cc55d675c75d0184bd8e38a inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac6fd43215c8f19082402387359330071 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#ac6fd43215c8f19082402387359330071">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:ac6fd43215c8f19082402387359330071 inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal7.html#ac6fd43215c8f19082402387359330071">More...</a><br /></td></tr>
+<tr class="separator:ac6fd43215c8f19082402387359330071 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af8a93a4c8fb0b78fa6578e7dc95f5751 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html">signal7</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#af8a93a4c8fb0b78fa6578e7dc95f5751">operator=</a> (const <a class="el" href="classsigc_1_1signal7.html">signal7</a> & src)</td></tr>
+<tr class="separator:af8a93a4c8fb0b78fa6578e7dc95f5751 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac06938f5cb6ff60a1bd5eaa32c990eea inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html">signal7</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#ac06938f5cb6ff60a1bd5eaa32c990eea">operator=</a> (<a class="el" href="classsigc_1_1signal7.html">signal7</a> && src)</td></tr>
+<tr class="separator:ac06938f5cb6ff60a1bd5eaa32c990eea inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a68153d9079b4881352113079cd6216f7 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a68153d9079b4881352113079cd6216f7">slots</a> ()</td></tr>
+<tr class="memdesc:a68153d9079b4881352113079cd6216f7 inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal7.html#a68153d9079b4881352113079cd6216f7">More...</a><br /></td></tr>
+<tr class="separator:a68153d9079b4881352113079cd6216f7 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a42509108239296e424844df2cd330aca inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a42509108239296e424844df2cd330aca">slots</a> () const</td></tr>
+<tr class="memdesc:a42509108239296e424844df2cd330aca inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal7.html#a42509108239296e424844df2cd330aca">More...</a><br /></td></tr>
+<tr class="separator:a42509108239296e424844df2cd330aca inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal7"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal7')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td></tr>
+<tr class="memitem:a6eef6225eba66a86dd32c3f3b79845f7 inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a6eef6225eba66a86dd32c3f3b79845f7">const_iterator</a></td></tr>
+<tr class="separator:a6eef6225eba66a86dd32c3f3b79845f7 inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1ba32ad7dae0c05a4012ada78077505 inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#ad1ba32ad7dae0c05a4012ada78077505">const_reverse_iterator</a></td></tr>
+<tr class="separator:ad1ba32ad7dae0c05a4012ada78077505 inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7fa856e67a31c86538db7c289a6870e3 inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a7fa856e67a31c86538db7c289a6870e3">emitter_type</a></td></tr>
+<tr class="separator:a7fa856e67a31c86538db7c289a6870e3 inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abc62e52cc684f917577a2fe3cd914d4a inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a">iterator</a></td></tr>
+<tr class="separator:abc62e52cc684f917577a2fe3cd914d4a inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5a75d73a254cf91a0f3ad1cd3545e29f inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a></td></tr>
+<tr class="separator:a5a75d73a254cf91a0f3ad1cd3545e29f inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a59c9c9fee7a98528839df592241351a9 inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a59c9c9fee7a98528839df592241351a9">reverse_iterator</a></td></tr>
+<tr class="separator:a59c9c9fee7a98528839df592241351a9 inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a79686c2174ab01dc23394953955ff003 inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003">slot_list_type</a></td></tr>
+<tr class="separator:a79686c2174ab01dc23394953955ff003 inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a72ee8c51eea3d1ba99eb9b512dfccd81 inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a></td></tr>
+<tr class="separator:a72ee8c51eea3d1ba99eb9b512dfccd81 inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1 = nil, class T_arg2 = nil, class T_arg3 = nil, class T_arg4 = nil, class T_arg5 = nil, class T_arg6 = nil, class T_arg7 = nil><br />
+template <class T_accumulator><br />
+class sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::accumulated< T_accumulator ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates. </p>
+<p>Like <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> but the additional template parameter <em>T_accumulator</em> defines the accumulator type that should be used.</p>
+<p>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' <a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01554.html#ga1383aaa1e6ca24ab907dea89ea4c3118">operator*()</a> executes the slot. The return value is buffered, so that in an expression like</p><div class="fragment"><div class="line">a = (*i) * (*i); </div>
+</div><!-- fragment --><p> the slot is executed only once. The accumulator must define its return value as <code>result_type</code>.</p>
+<dl class="section user"><dt>Example 1:</dt><dd>This accumulator calculates the arithmetic mean value: <div class="fragment"><div class="line"><span class="keyword">struct </span>arithmetic_mean_accumulator</div>
+<div class="line">{</div>
+<div class="line"> <span class="keyword">typedef</span> <span class="keywordtype">double</span> <a class="code" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a>;</div>
+<div class="line"> <span class="keyword">template</span><<span class="keyword">typename</span> T_iterator></div>
+<div class="line"> <a class="code" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> <a class="code" href="classsigc_1_1signal7.html#ac6fd43215c8f19082402387359330071">operator()</a>(T_iterator first, T_iterator last)<span class="keyword"> const</span></div>
+<div class="line"><span class="keyword"> </span>{</div>
+<div class="line"> <a class="code" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> value_ = 0;</div>
+<div class="line"> <span class="keywordtype">int</span> n_ = 0;</div>
+<div class="line"> <span class="keywordflow">for</span> (; first != last; ++first, ++n_)</div>
+<div class="line"> value_ += *first;</div>
+<div class="line"> <span class="keywordflow">return</span> value_ / n_;</div>
+<div class="line"> }</div>
+<div class="line">};</div>
+<div class="ttc" id="aclasssigc_1_1signal7_html_a5a75d73a254cf91a0f3ad1cd3545e29f"><div class="ttname"><a href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::result_type</a></div><div class="ttdeci">emitter_type::result_type result_type</div><div class="ttdef"><b>Definition:</b> signal.h:3842</div></div>
+<div class="ttc" id="aclasssigc_1_1signal7_html_ac6fd43215c8f19082402387359330071"><div class="ttname"><a href="classsigc_1_1signal7.html#ac6fd43215c8f19082402387359330071">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::operator()</a></div><div class="ttdeci">result_type operator()(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</div><div class="ttdoc">Triggers the emission of the signal (see emit()).</div><div class="ttdef"><b>Definition:</b> signal.h:3914</div></div>
+</div><!-- fragment --></dd></dl>
+<dl class="section user"><dt>Example 2:</dt><dd>This accumulator stops signal emission when a slot returns zero: <div class="fragment"><div class="line"><span class="keyword">struct </span>interruptable_accumulator</div>
+<div class="line">{</div>
+<div class="line"> <span class="keyword">typedef</span> <span class="keywordtype">bool</span> <a class="code" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a>;</div>
+<div class="line"> <span class="keyword">template</span><<span class="keyword">typename</span> T_iterator></div>
+<div class="line"> <a class="code" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> <a class="code" href="classsigc_1_1signal7.html#ac6fd43215c8f19082402387359330071">operator()</a>(T_iterator first, T_iterator last)<span class="keyword"> const</span></div>
+<div class="line"><span class="keyword"> </span>{</div>
+<div class="line"> <span class="keywordflow">for</span> (; first != last; ++first, ++n_)</div>
+<div class="line"> <span class="keywordflow">if</span> (!*first) <span class="keywordflow">return</span> <span class="keyword">false</span>;</div>
+<div class="line"> <span class="keywordflow">return</span> <span class="keyword">true</span>;</div>
+<div class="line"> }</div>
+<div class="line">};</div>
+</div><!-- fragment --> </dd></dl>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a46bed3515606e0a5807f08e239891ca0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a46bed3515606e0a5807f08e239891ca0">◆ </a></span>accumulated() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 = nil, class T_arg2 = nil, class T_arg3 = nil, class T_arg4 = nil, class T_arg5 = nil, class T_arg6 = nil, class T_arg7 = nil> </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1signal_1_1accumulated.html">accumulated</a>< T_accumulator >::<a class="el" href="classsigc_1_1signal_1_1accumulated.html">accumulated</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a032428476a190d9dea6313f70e5b8a10"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a032428476a190d9dea6313f70e5b8a10">◆ </a></span>accumulated() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 = nil, class T_arg2 = nil, class T_arg3 = nil, class T_arg4 = nil, class T_arg5 = nil, class T_arg6 = nil, class T_arg7 = nil> </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1signal_1_1accumulated.html">accumulated</a>< T_accumulator >::<a class="el" href="classsigc_1_1signal_1_1accumulated.html">accumulated</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal_1_1accumulated.html">accumulated</a>< T_accumulator > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::accumulated< T_accumulator >" name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::accumulated< T_accumulator >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::signal# templates." alt="" coords="588,5,788,91"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal7.html" title=" " alt="" coords="351,13,540,83"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="169,35,303,61"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="5,35,121,61"/>
+</map>
--- /dev/null
+4481d1493cbf90e631c7f5f481372fc8
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a66c302607cf4fb74f5d3352f9c394c9b">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a1754aa5a8959da0bb55e42864a8365af">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#ac88a9c4e9bab5ad04c66d3f5d3978f0f">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#aff490e7f75a83aa2f324a859f9071a79">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a2e8b355902f0646fb34b52b495123167">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#acdd2683223e4701f58350152f32f4488">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a1acee11287974cdac1bc63c856e5331d">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a97ae4180e80ac60b564fec58d1732317">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#affec011fd6e9605f10e50fdd4db424d8">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#ace9ebd1d47d825a1ee18ae0b2c639ab1">operator=</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a6cbe2b81b53c97bc39c26bbedcb070f1">operator=</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#ad7a4ab249b17bffccbfe441aa1420dd9">signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::operator=</a>(const signal6 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a012b9abce888e420e1b5b3f29aa98900">signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::operator=</a>(signal6 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a79b741b3f0def8f52fc185ad50b60673">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a1dd1e779ef29d6df2b570847c4f2819e">signal</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#aa070e4d37a8a06ef9fc02256d236472c">signal</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a09609c04d7601601c9726aef1c74ecc7">signal</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#af7f529bbd9cf26d468ed18426b9b51ea">signal6</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a0244dde296bd892c590c86ced5281e3b">signal6</a>(const signal6 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#ab717ce413bda79e1de41944d0675a8ca">signal6</a>(signal6 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a0e4fea9bd1ed35f9d60bbc26c4fae007">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#af44115a7bfa4586fc5312259a1df9567">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#ac66109f683ae86898ae10109a80b28a4">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::accumulated< T_accumulator > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::accumulated< T_accumulator ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html#a0b18943e223f1ae150ee5541673a2e29">accumulated</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html#a3e41ce87d15bc90960abd857ca80aed9">accumulated</a>(const accumulated & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a057789cc27a920700e240f8f3d78dd65">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a05cfed3d3e29158424bc810168d78153">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a17e79eed46f178a12d2751eddcf85290">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#ad5ba46907fe236e0cff806888696d569">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#aa6d2e202263e3879f0d3949612d7fcdf">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a7d77e5fa748b024842bf92e28cf0f4ab">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#acee689b441305fcee098345729fc28f3">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a7b01481c87d4ec9c03095e76cb502c24">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a7a5bb7b92f49e99354caf50bfef16907">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a2c3d9a6d8b499da389672f44f8044ce6">operator=</a>(const signal5 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a5c652f8e549a2c555b79db8e8a05f407">operator=</a>(signal5 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#ab684cb9920d0f7949f28c03d50b58275">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#af717d1a6fd8612da84dce33fe6640b7a">signal5</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a7885861b9cdbacbe2d58a13cd96ec265">signal5</a>(const signal5 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#af39141aeec9dc870dd28926202493de4">signal5</a>(signal5 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a4c79ab227fc3b31b990e925636f7788e">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#ad6a4ae2a214d8710be6e36bb425587fc">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a32af276c9c56abbb0386f54262b40be5">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::accumulated< T_accumulator > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::accumulated< T_accumulator ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html#a0f2cc39e9f222a296072f8c05ad98796">accumulated</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html#a239f7a4fefc7cb2cc6c4fb6c9c332d2f">accumulated</a>(const accumulated & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a66c302607cf4fb74f5d3352f9c394c9b">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a1754aa5a8959da0bb55e42864a8365af">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#ac88a9c4e9bab5ad04c66d3f5d3978f0f">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#aff490e7f75a83aa2f324a859f9071a79">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a2e8b355902f0646fb34b52b495123167">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#acdd2683223e4701f58350152f32f4488">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a1acee11287974cdac1bc63c856e5331d">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a97ae4180e80ac60b564fec58d1732317">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#affec011fd6e9605f10e50fdd4db424d8">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#ad7a4ab249b17bffccbfe441aa1420dd9">operator=</a>(const signal6 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a012b9abce888e420e1b5b3f29aa98900">operator=</a>(signal6 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a79b741b3f0def8f52fc185ad50b60673">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#af7f529bbd9cf26d468ed18426b9b51ea">signal6</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a0244dde296bd892c590c86ced5281e3b">signal6</a>(const signal6 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#ab717ce413bda79e1de41944d0675a8ca">signal6</a>(signal6 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a0e4fea9bd1ed35f9d60bbc26c4fae007">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#af44115a7bfa4586fc5312259a1df9567">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#ac66109f683ae86898ae10109a80b28a4">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::accumulated< T_accumulator >" name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::accumulated< T_accumulator >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::signal6 template." alt="" coords="577,5,852,76"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal6.html" title=" " alt="" coords="351,5,529,76"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="169,27,303,54"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="5,27,121,54"/>
+</map>
--- /dev/null
+b0fc241b597850b51a9f7a8c5fa7e95b
\ No newline at end of file
--- /dev/null
+<map id="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::accumulated< T_accumulator >" name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::accumulated< T_accumulator >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::signal5 template." alt="" coords="5,259,260,329"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal5.html" title=" " alt="" coords="12,155,253,211"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="66,80,199,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="75,5,191,32"/>
+</map>
--- /dev/null
+274d71f3a27590d1512cce183b9c0a1e
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a057789cc27a920700e240f8f3d78dd65">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a05cfed3d3e29158424bc810168d78153">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a17e79eed46f178a12d2751eddcf85290">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#ad5ba46907fe236e0cff806888696d569">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#aa6d2e202263e3879f0d3949612d7fcdf">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a7d77e5fa748b024842bf92e28cf0f4ab">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#acee689b441305fcee098345729fc28f3">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a7b01481c87d4ec9c03095e76cb502c24">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a7a5bb7b92f49e99354caf50bfef16907">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a4d6e1453a0b4284cc19996e36cff5eef">operator=</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a05a22fca63088154ba5c15b221e30760">operator=</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a2c3d9a6d8b499da389672f44f8044ce6">signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil >::operator=</a>(const signal5 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a5c652f8e549a2c555b79db8e8a05f407">signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil >::operator=</a>(signal5 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#ab684cb9920d0f7949f28c03d50b58275">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a5e64ba037f3567ab5dbb49811a447b2c">signal</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a2f45d321526546618c56c1d5400507d2">signal</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a3447b5d32b839fa22ac7845ea448d2b4">signal</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#af717d1a6fd8612da84dce33fe6640b7a">signal5</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a7885861b9cdbacbe2d58a13cd96ec265">signal5</a>(const signal5 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#af39141aeec9dc870dd28926202493de4">signal5</a>(signal5 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a4c79ab227fc3b31b990e925636f7788e">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#ad6a4ae2a214d8710be6e36bb425587fc">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a32af276c9c56abbb0386f54262b40be5">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >" name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::signal6 template." alt="" coords="5,259,219,315"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal6.html" title=" " alt="" coords="5,155,219,211"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="45,80,179,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="54,5,170,32"/>
+</map>
--- /dev/null
+e05bf574ee4b158683737253a93631c5
\ No newline at end of file
--- /dev/null
+<map id="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >" name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::signal5 template." alt="" coords="5,259,191,315"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal5.html" title=" " alt="" coords="9,155,187,211"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="31,80,165,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="40,5,156,32"/>
+</map>
--- /dev/null
+0e805da5e73b560da5cc4ffbec337ebc
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::accumulated< T_accumulator > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__ar16a14c152bc5ff346d9997f7152c0448.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::accumulated< T_accumulator > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal5.html" title="Signal declaration.">sigc::signal5</a> template.
+ <a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::accumulated< T_accumulator >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__ar2a3f9cda8e57479189997c283e69f5ff.png" border="0" usemap="#asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" id="asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::signal5 template." alt="" coords="5,259,260,329"/>
+<area shape="rect" href="classsigc_1_1signal5.html" title=" " alt="" coords="12,155,253,211"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="66,80,199,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="75,5,191,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a0b18943e223f1ae150ee5541673a2e29"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html#a0b18943e223f1ae150ee5541673a2e29">accumulated</a> ()</td></tr>
+<tr class="separator:a0b18943e223f1ae150ee5541673a2e29"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3e41ce87d15bc90960abd857ca80aed9"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html#a3e41ce87d15bc90960abd857ca80aed9">accumulated</a> (const accumulated & src)</td></tr>
+<tr class="separator:a3e41ce87d15bc90960abd857ca80aed9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal5"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal5')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td></tr>
+<tr class="memitem:af717d1a6fd8612da84dce33fe6640b7a inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#af717d1a6fd8612da84dce33fe6640b7a">signal5</a> ()</td></tr>
+<tr class="separator:af717d1a6fd8612da84dce33fe6640b7a inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7885861b9cdbacbe2d58a13cd96ec265 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a7885861b9cdbacbe2d58a13cd96ec265">signal5</a> (const <a class="el" href="classsigc_1_1signal5.html">signal5</a> & src)</td></tr>
+<tr class="separator:a7885861b9cdbacbe2d58a13cd96ec265 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af39141aeec9dc870dd28926202493de4 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#af39141aeec9dc870dd28926202493de4">signal5</a> (<a class="el" href="classsigc_1_1signal5.html">signal5</a> && src)</td></tr>
+<tr class="separator:af39141aeec9dc870dd28926202493de4 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a057789cc27a920700e240f8f3d78dd65 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#acee689b441305fcee098345729fc28f3">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a057789cc27a920700e240f8f3d78dd65">connect</a> (const <a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:a057789cc27a920700e240f8f3d78dd65 inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal5.html#a057789cc27a920700e240f8f3d78dd65">More...</a><br /></td></tr>
+<tr class="separator:a057789cc27a920700e240f8f3d78dd65 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a05cfed3d3e29158424bc810168d78153 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#acee689b441305fcee098345729fc28f3">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a05cfed3d3e29158424bc810168d78153">connect</a> (<a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:a05cfed3d3e29158424bc810168d78153 inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal5.html#a05cfed3d3e29158424bc810168d78153">More...</a><br /></td></tr>
+<tr class="separator:a05cfed3d3e29158424bc810168d78153 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8772fef879632c4ff45e82b4b00b0157 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:a8772fef879632c4ff45e82b4b00b0157 inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157">More...</a><br /></td></tr>
+<tr class="separator:a8772fef879632c4ff45e82b4b00b0157 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa6d2e202263e3879f0d3949612d7fcdf inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#aa6d2e202263e3879f0d3949612d7fcdf">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:aa6d2e202263e3879f0d3949612d7fcdf inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal5.html#aa6d2e202263e3879f0d3949612d7fcdf">More...</a><br /></td></tr>
+<tr class="separator:aa6d2e202263e3879f0d3949612d7fcdf inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7b01481c87d4ec9c03095e76cb502c24 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html">bound_const_mem_functor5</a>< <a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a>, <a class="el" href="classsigc_1_1signal5.html">signal5</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a7b01481c87d4ec9c03095e76cb502c24">make_slot</a> () const</td></tr>
+<tr class="memdesc:a7b01481c87d4ec9c03095e76cb502c24 inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal5.html#a7b01481c87d4ec9c03095e76cb502c24">More...</a><br /></td></tr>
+<tr class="separator:a7b01481c87d4ec9c03095e76cb502c24 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7a5bb7b92f49e99354caf50bfef16907 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a7a5bb7b92f49e99354caf50bfef16907">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:a7a5bb7b92f49e99354caf50bfef16907 inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal5.html#a7a5bb7b92f49e99354caf50bfef16907">More...</a><br /></td></tr>
+<tr class="separator:a7a5bb7b92f49e99354caf50bfef16907 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2c3d9a6d8b499da389672f44f8044ce6 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html">signal5</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a2c3d9a6d8b499da389672f44f8044ce6">operator=</a> (const <a class="el" href="classsigc_1_1signal5.html">signal5</a> & src)</td></tr>
+<tr class="separator:a2c3d9a6d8b499da389672f44f8044ce6 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5c652f8e549a2c555b79db8e8a05f407 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html">signal5</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a5c652f8e549a2c555b79db8e8a05f407">operator=</a> (<a class="el" href="classsigc_1_1signal5.html">signal5</a> && src)</td></tr>
+<tr class="separator:a5c652f8e549a2c555b79db8e8a05f407 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad6a4ae2a214d8710be6e36bb425587fc inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#a4c79ab227fc3b31b990e925636f7788e">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#ad6a4ae2a214d8710be6e36bb425587fc">slots</a> ()</td></tr>
+<tr class="memdesc:ad6a4ae2a214d8710be6e36bb425587fc inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal5.html#ad6a4ae2a214d8710be6e36bb425587fc">More...</a><br /></td></tr>
+<tr class="separator:ad6a4ae2a214d8710be6e36bb425587fc inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a32af276c9c56abbb0386f54262b40be5 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal5.html#a4c79ab227fc3b31b990e925636f7788e">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a32af276c9c56abbb0386f54262b40be5">slots</a> () const</td></tr>
+<tr class="memdesc:a32af276c9c56abbb0386f54262b40be5 inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal5.html#a32af276c9c56abbb0386f54262b40be5">More...</a><br /></td></tr>
+<tr class="separator:a32af276c9c56abbb0386f54262b40be5 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal5"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal5')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td></tr>
+<tr class="memitem:a17e79eed46f178a12d2751eddcf85290 inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a17e79eed46f178a12d2751eddcf85290">const_iterator</a></td></tr>
+<tr class="separator:a17e79eed46f178a12d2751eddcf85290 inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad5ba46907fe236e0cff806888696d569 inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#ad5ba46907fe236e0cff806888696d569">const_reverse_iterator</a></td></tr>
+<tr class="separator:ad5ba46907fe236e0cff806888696d569 inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7d77e5fa748b024842bf92e28cf0f4ab inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a7d77e5fa748b024842bf92e28cf0f4ab">emitter_type</a></td></tr>
+<tr class="separator:a7d77e5fa748b024842bf92e28cf0f4ab inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acee689b441305fcee098345729fc28f3 inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#acee689b441305fcee098345729fc28f3">iterator</a></td></tr>
+<tr class="separator:acee689b441305fcee098345729fc28f3 inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aceb959897dcf8e3c7209c283d4848b94 inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a></td></tr>
+<tr class="separator:aceb959897dcf8e3c7209c283d4848b94 inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab684cb9920d0f7949f28c03d50b58275 inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#ab684cb9920d0f7949f28c03d50b58275">reverse_iterator</a></td></tr>
+<tr class="separator:ab684cb9920d0f7949f28c03d50b58275 inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4c79ab227fc3b31b990e925636f7788e inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a4c79ab227fc3b31b990e925636f7788e">slot_list_type</a></td></tr>
+<tr class="separator:a4c79ab227fc3b31b990e925636f7788e inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae73737aad5d854c6466e8b13e7963b9e inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a></td></tr>
+<tr class="separator:ae73737aad5d854c6466e8b13e7963b9e inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5><br />
+template <class T_accumulator><br />
+class sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::accumulated< T_accumulator ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal5.html" title="Signal declaration.">sigc::signal5</a> template. </p>
+<p>Like <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> but the additional template parameter <em>T_accumulator</em> defines the accumulator type that should be used. </p>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a0b18943e223f1ae150ee5541673a2e29"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0b18943e223f1ae150ee5541673a2e29">◆ </a></span>accumulated() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a3e41ce87d15bc90960abd857ca80aed9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3e41ce87d15bc90960abd857ca80aed9">◆ </a></span>accumulated() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramtype">const accumulated & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::accumulated< T_accumulator > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__ar1b790d5e11b1dad6454242a5312e335f.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::accumulated< T_accumulator > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal6.html" title="Signal declaration.">sigc::signal6</a> template.
+ <a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::accumulated< T_accumulator >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__ar1da4c680404aa7c8c338bb136fd6dbea.png" border="0" usemap="#asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" id="asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::signal6 template." alt="" coords="577,5,852,76"/>
+<area shape="rect" href="classsigc_1_1signal6.html" title=" " alt="" coords="351,5,529,76"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="169,27,303,54"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="5,27,121,54"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a0f2cc39e9f222a296072f8c05ad98796"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html#a0f2cc39e9f222a296072f8c05ad98796">accumulated</a> ()</td></tr>
+<tr class="separator:a0f2cc39e9f222a296072f8c05ad98796"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a239f7a4fefc7cb2cc6c4fb6c9c332d2f"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html#a239f7a4fefc7cb2cc6c4fb6c9c332d2f">accumulated</a> (const accumulated & src)</td></tr>
+<tr class="separator:a239f7a4fefc7cb2cc6c4fb6c9c332d2f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal6"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal6')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td></tr>
+<tr class="memitem:af7f529bbd9cf26d468ed18426b9b51ea inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#af7f529bbd9cf26d468ed18426b9b51ea">signal6</a> ()</td></tr>
+<tr class="separator:af7f529bbd9cf26d468ed18426b9b51ea inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0244dde296bd892c590c86ced5281e3b inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a0244dde296bd892c590c86ced5281e3b">signal6</a> (const <a class="el" href="classsigc_1_1signal6.html">signal6</a> & src)</td></tr>
+<tr class="separator:a0244dde296bd892c590c86ced5281e3b inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab717ce413bda79e1de41944d0675a8ca inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#ab717ce413bda79e1de41944d0675a8ca">signal6</a> (<a class="el" href="classsigc_1_1signal6.html">signal6</a> && src)</td></tr>
+<tr class="separator:ab717ce413bda79e1de41944d0675a8ca inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a66c302607cf4fb74f5d3352f9c394c9b inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a1acee11287974cdac1bc63c856e5331d">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a66c302607cf4fb74f5d3352f9c394c9b">connect</a> (const <a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:a66c302607cf4fb74f5d3352f9c394c9b inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal6.html#a66c302607cf4fb74f5d3352f9c394c9b">More...</a><br /></td></tr>
+<tr class="separator:a66c302607cf4fb74f5d3352f9c394c9b inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1754aa5a8959da0bb55e42864a8365af inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a1acee11287974cdac1bc63c856e5331d">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a1754aa5a8959da0bb55e42864a8365af">connect</a> (<a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:a1754aa5a8959da0bb55e42864a8365af inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal6.html#a1754aa5a8959da0bb55e42864a8365af">More...</a><br /></td></tr>
+<tr class="separator:a1754aa5a8959da0bb55e42864a8365af inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a6361a9230323e7c7e86e2c9e6c8fe21b inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:a6361a9230323e7c7e86e2c9e6c8fe21b inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b">More...</a><br /></td></tr>
+<tr class="separator:a6361a9230323e7c7e86e2c9e6c8fe21b inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2e8b355902f0646fb34b52b495123167 inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a2e8b355902f0646fb34b52b495123167">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:a2e8b355902f0646fb34b52b495123167 inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal6.html#a2e8b355902f0646fb34b52b495123167">More...</a><br /></td></tr>
+<tr class="separator:a2e8b355902f0646fb34b52b495123167 inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a97ae4180e80ac60b564fec58d1732317 inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html">bound_const_mem_functor6</a>< <a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a>, <a class="el" href="classsigc_1_1signal6.html">signal6</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a97ae4180e80ac60b564fec58d1732317">make_slot</a> () const</td></tr>
+<tr class="memdesc:a97ae4180e80ac60b564fec58d1732317 inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal6.html#a97ae4180e80ac60b564fec58d1732317">More...</a><br /></td></tr>
+<tr class="separator:a97ae4180e80ac60b564fec58d1732317 inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:affec011fd6e9605f10e50fdd4db424d8 inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#affec011fd6e9605f10e50fdd4db424d8">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:affec011fd6e9605f10e50fdd4db424d8 inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal6.html#affec011fd6e9605f10e50fdd4db424d8">More...</a><br /></td></tr>
+<tr class="separator:affec011fd6e9605f10e50fdd4db424d8 inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad7a4ab249b17bffccbfe441aa1420dd9 inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html">signal6</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#ad7a4ab249b17bffccbfe441aa1420dd9">operator=</a> (const <a class="el" href="classsigc_1_1signal6.html">signal6</a> & src)</td></tr>
+<tr class="separator:ad7a4ab249b17bffccbfe441aa1420dd9 inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a012b9abce888e420e1b5b3f29aa98900 inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html">signal6</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a012b9abce888e420e1b5b3f29aa98900">operator=</a> (<a class="el" href="classsigc_1_1signal6.html">signal6</a> && src)</td></tr>
+<tr class="separator:a012b9abce888e420e1b5b3f29aa98900 inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af44115a7bfa4586fc5312259a1df9567 inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a0e4fea9bd1ed35f9d60bbc26c4fae007">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#af44115a7bfa4586fc5312259a1df9567">slots</a> ()</td></tr>
+<tr class="memdesc:af44115a7bfa4586fc5312259a1df9567 inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal6.html#af44115a7bfa4586fc5312259a1df9567">More...</a><br /></td></tr>
+<tr class="separator:af44115a7bfa4586fc5312259a1df9567 inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac66109f683ae86898ae10109a80b28a4 inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal6.html#a0e4fea9bd1ed35f9d60bbc26c4fae007">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#ac66109f683ae86898ae10109a80b28a4">slots</a> () const</td></tr>
+<tr class="memdesc:ac66109f683ae86898ae10109a80b28a4 inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal6.html#ac66109f683ae86898ae10109a80b28a4">More...</a><br /></td></tr>
+<tr class="separator:ac66109f683ae86898ae10109a80b28a4 inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal6"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal6')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td></tr>
+<tr class="memitem:ac88a9c4e9bab5ad04c66d3f5d3978f0f inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#ac88a9c4e9bab5ad04c66d3f5d3978f0f">const_iterator</a></td></tr>
+<tr class="separator:ac88a9c4e9bab5ad04c66d3f5d3978f0f inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aff490e7f75a83aa2f324a859f9071a79 inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#aff490e7f75a83aa2f324a859f9071a79">const_reverse_iterator</a></td></tr>
+<tr class="separator:aff490e7f75a83aa2f324a859f9071a79 inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acdd2683223e4701f58350152f32f4488 inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#acdd2683223e4701f58350152f32f4488">emitter_type</a></td></tr>
+<tr class="separator:acdd2683223e4701f58350152f32f4488 inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1acee11287974cdac1bc63c856e5331d inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a1acee11287974cdac1bc63c856e5331d">iterator</a></td></tr>
+<tr class="separator:a1acee11287974cdac1bc63c856e5331d inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a56f1acca230e676dae665d41a10acc8f inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a></td></tr>
+<tr class="separator:a56f1acca230e676dae665d41a10acc8f inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a79b741b3f0def8f52fc185ad50b60673 inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a79b741b3f0def8f52fc185ad50b60673">reverse_iterator</a></td></tr>
+<tr class="separator:a79b741b3f0def8f52fc185ad50b60673 inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0e4fea9bd1ed35f9d60bbc26c4fae007 inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a0e4fea9bd1ed35f9d60bbc26c4fae007">slot_list_type</a></td></tr>
+<tr class="separator:a0e4fea9bd1ed35f9d60bbc26c4fae007 inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac62cdf4db7dcd5e30975e51e978f03db inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a></td></tr>
+<tr class="separator:ac62cdf4db7dcd5e30975e51e978f03db inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6><br />
+template <class T_accumulator><br />
+class sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::accumulated< T_accumulator ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal6.html" title="Signal declaration.">sigc::signal6</a> template. </p>
+<p>Like <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> but the additional template parameter <em>T_accumulator</em> defines the accumulator type that should be used. </p>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a0f2cc39e9f222a296072f8c05ad98796"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0f2cc39e9f222a296072f8c05ad98796">◆ </a></span>accumulated() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, <a class="el" href="structsigc_1_1nil.html">nil</a> >::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a239f7a4fefc7cb2cc6c4fb6c9c332d2f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a239f7a4fefc7cb2cc6c4fb6c9c332d2f">◆ </a></span>accumulated() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, <a class="el" href="structsigc_1_1nil.html">nil</a> >::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramtype">const accumulated & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#nested-classes">Classes</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__ar01b49059ecd092e1ea927a389afae4ab.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal6.html" title="Signal declaration.">sigc::signal6</a> template.
+ <a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__ar821f8b15c79da4460a4c99304ac8d504.png" border="0" usemap="#asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4_inherit__map" id="asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::signal6 template." alt="" coords="5,259,219,315"/>
+<area shape="rect" href="classsigc_1_1signal6.html" title=" " alt="" coords="5,155,219,211"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="45,80,179,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="54,5,170,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Classes</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html">accumulated</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal6.html" title="Signal declaration.">sigc::signal6</a> template. <a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a1dd1e779ef29d6df2b570847c4f2819e"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a1dd1e779ef29d6df2b570847c4f2819e">signal</a> ()</td></tr>
+<tr class="separator:a1dd1e779ef29d6df2b570847c4f2819e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa070e4d37a8a06ef9fc02256d236472c"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#aa070e4d37a8a06ef9fc02256d236472c">signal</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:aa070e4d37a8a06ef9fc02256d236472c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a09609c04d7601601c9726aef1c74ecc7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a09609c04d7601601c9726aef1c74ecc7">signal</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:a09609c04d7601601c9726aef1c74ecc7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ace9ebd1d47d825a1ee18ae0b2c639ab1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#ace9ebd1d47d825a1ee18ae0b2c639ab1">operator=</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:ace9ebd1d47d825a1ee18ae0b2c639ab1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a6cbe2b81b53c97bc39c26bbedcb070f1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a6cbe2b81b53c97bc39c26bbedcb070f1">operator=</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:a6cbe2b81b53c97bc39c26bbedcb070f1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal6"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal6')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td></tr>
+<tr class="memitem:af7f529bbd9cf26d468ed18426b9b51ea inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#af7f529bbd9cf26d468ed18426b9b51ea">signal6</a> ()</td></tr>
+<tr class="separator:af7f529bbd9cf26d468ed18426b9b51ea inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0244dde296bd892c590c86ced5281e3b inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a0244dde296bd892c590c86ced5281e3b">signal6</a> (const <a class="el" href="classsigc_1_1signal6.html">signal6</a> & src)</td></tr>
+<tr class="separator:a0244dde296bd892c590c86ced5281e3b inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab717ce413bda79e1de41944d0675a8ca inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#ab717ce413bda79e1de41944d0675a8ca">signal6</a> (<a class="el" href="classsigc_1_1signal6.html">signal6</a> && src)</td></tr>
+<tr class="separator:ab717ce413bda79e1de41944d0675a8ca inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a66c302607cf4fb74f5d3352f9c394c9b inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a1acee11287974cdac1bc63c856e5331d">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a66c302607cf4fb74f5d3352f9c394c9b">connect</a> (const <a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:a66c302607cf4fb74f5d3352f9c394c9b inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal6.html#a66c302607cf4fb74f5d3352f9c394c9b">More...</a><br /></td></tr>
+<tr class="separator:a66c302607cf4fb74f5d3352f9c394c9b inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1754aa5a8959da0bb55e42864a8365af inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a1acee11287974cdac1bc63c856e5331d">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a1754aa5a8959da0bb55e42864a8365af">connect</a> (<a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:a1754aa5a8959da0bb55e42864a8365af inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal6.html#a1754aa5a8959da0bb55e42864a8365af">More...</a><br /></td></tr>
+<tr class="separator:a1754aa5a8959da0bb55e42864a8365af inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a6361a9230323e7c7e86e2c9e6c8fe21b inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:a6361a9230323e7c7e86e2c9e6c8fe21b inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b">More...</a><br /></td></tr>
+<tr class="separator:a6361a9230323e7c7e86e2c9e6c8fe21b inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2e8b355902f0646fb34b52b495123167 inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a2e8b355902f0646fb34b52b495123167">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:a2e8b355902f0646fb34b52b495123167 inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal6.html#a2e8b355902f0646fb34b52b495123167">More...</a><br /></td></tr>
+<tr class="separator:a2e8b355902f0646fb34b52b495123167 inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a97ae4180e80ac60b564fec58d1732317 inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html">bound_const_mem_functor6</a>< <a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a>, <a class="el" href="classsigc_1_1signal6.html">signal6</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a97ae4180e80ac60b564fec58d1732317">make_slot</a> () const</td></tr>
+<tr class="memdesc:a97ae4180e80ac60b564fec58d1732317 inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal6.html#a97ae4180e80ac60b564fec58d1732317">More...</a><br /></td></tr>
+<tr class="separator:a97ae4180e80ac60b564fec58d1732317 inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:affec011fd6e9605f10e50fdd4db424d8 inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#affec011fd6e9605f10e50fdd4db424d8">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:affec011fd6e9605f10e50fdd4db424d8 inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal6.html#affec011fd6e9605f10e50fdd4db424d8">More...</a><br /></td></tr>
+<tr class="separator:affec011fd6e9605f10e50fdd4db424d8 inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad7a4ab249b17bffccbfe441aa1420dd9 inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html">signal6</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#ad7a4ab249b17bffccbfe441aa1420dd9">operator=</a> (const <a class="el" href="classsigc_1_1signal6.html">signal6</a> & src)</td></tr>
+<tr class="separator:ad7a4ab249b17bffccbfe441aa1420dd9 inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a012b9abce888e420e1b5b3f29aa98900 inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html">signal6</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a012b9abce888e420e1b5b3f29aa98900">operator=</a> (<a class="el" href="classsigc_1_1signal6.html">signal6</a> && src)</td></tr>
+<tr class="separator:a012b9abce888e420e1b5b3f29aa98900 inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af44115a7bfa4586fc5312259a1df9567 inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a0e4fea9bd1ed35f9d60bbc26c4fae007">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#af44115a7bfa4586fc5312259a1df9567">slots</a> ()</td></tr>
+<tr class="memdesc:af44115a7bfa4586fc5312259a1df9567 inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal6.html#af44115a7bfa4586fc5312259a1df9567">More...</a><br /></td></tr>
+<tr class="separator:af44115a7bfa4586fc5312259a1df9567 inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac66109f683ae86898ae10109a80b28a4 inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal6.html#a0e4fea9bd1ed35f9d60bbc26c4fae007">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#ac66109f683ae86898ae10109a80b28a4">slots</a> () const</td></tr>
+<tr class="memdesc:ac66109f683ae86898ae10109a80b28a4 inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal6.html#ac66109f683ae86898ae10109a80b28a4">More...</a><br /></td></tr>
+<tr class="separator:ac66109f683ae86898ae10109a80b28a4 inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal6"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal6')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td></tr>
+<tr class="memitem:ac88a9c4e9bab5ad04c66d3f5d3978f0f inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#ac88a9c4e9bab5ad04c66d3f5d3978f0f">const_iterator</a></td></tr>
+<tr class="separator:ac88a9c4e9bab5ad04c66d3f5d3978f0f inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aff490e7f75a83aa2f324a859f9071a79 inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#aff490e7f75a83aa2f324a859f9071a79">const_reverse_iterator</a></td></tr>
+<tr class="separator:aff490e7f75a83aa2f324a859f9071a79 inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acdd2683223e4701f58350152f32f4488 inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, <a class="el" href="structsigc_1_1nil.html">nil</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#acdd2683223e4701f58350152f32f4488">emitter_type</a></td></tr>
+<tr class="separator:acdd2683223e4701f58350152f32f4488 inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1acee11287974cdac1bc63c856e5331d inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a1acee11287974cdac1bc63c856e5331d">iterator</a></td></tr>
+<tr class="separator:a1acee11287974cdac1bc63c856e5331d inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a56f1acca230e676dae665d41a10acc8f inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a></td></tr>
+<tr class="separator:a56f1acca230e676dae665d41a10acc8f inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a79b741b3f0def8f52fc185ad50b60673 inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a79b741b3f0def8f52fc185ad50b60673">reverse_iterator</a></td></tr>
+<tr class="separator:a79b741b3f0def8f52fc185ad50b60673 inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0e4fea9bd1ed35f9d60bbc26c4fae007 inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a0e4fea9bd1ed35f9d60bbc26c4fae007">slot_list_type</a></td></tr>
+<tr class="separator:a0e4fea9bd1ed35f9d60bbc26c4fae007 inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac62cdf4db7dcd5e30975e51e978f03db inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a></td></tr>
+<tr class="separator:ac62cdf4db7dcd5e30975e51e978f03db inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6><br />
+class sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal6.html" title="Signal declaration.">sigc::signal6</a> template. </p>
+<p>See the base class for useful methods. This is the template specialization of the unnumbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> template for 6 argument(s).</p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000008">Deprecated:</a></b></dt><dd>Please use the syntax similar to that used by std::function<>: </dd></dl>
+<div class="fragment"><div class="line"><a class="code" href="classsigc_1_1slot.html">sigc::slot</a><void(<span class="keywordtype">bool</span>, <span class="keywordtype">int</span>)> some_slot;</div>
+<div class="ttc" id="aclasssigc_1_1slot_html"><div class="ttname"><a href="classsigc_1_1slot.html">sigc::slot</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::slot# templates.</div><div class="ttdef"><b>Definition:</b> slot.h:1645</div></div>
+</div><!-- fragment --> </div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a1dd1e779ef29d6df2b570847c4f2819e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1dd1e779ef29d6df2b570847c4f2819e">◆ </a></span>signal() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aa070e4d37a8a06ef9fc02256d236472c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa070e4d37a8a06ef9fc02256d236472c">◆ </a></span>signal() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, <a class="el" href="structsigc_1_1nil.html">nil</a> > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a09609c04d7601601c9726aef1c74ecc7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a09609c04d7601601c9726aef1c74ecc7">◆ </a></span>signal() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, <a class="el" href="structsigc_1_1nil.html">nil</a> > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="ace9ebd1d47d825a1ee18ae0b2c639ab1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ace9ebd1d47d825a1ee18ae0b2c639ab1">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, <a class="el" href="structsigc_1_1nil.html">nil</a> > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a6cbe2b81b53c97bc39c26bbedcb070f1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a6cbe2b81b53c97bc39c26bbedcb070f1">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, <a class="el" href="structsigc_1_1nil.html">nil</a> > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#nested-classes">Classes</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__ar3adb4b941bace89a3f952c380bedda11.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal5.html" title="Signal declaration.">sigc::signal5</a> template.
+ <a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arbe5eef28da7cedf7c98aeec3dbe6d6b8.png" border="0" usemap="#asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4_inherit__map" id="asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::signal5 template." alt="" coords="5,259,191,315"/>
+<area shape="rect" href="classsigc_1_1signal5.html" title=" " alt="" coords="9,155,187,211"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="31,80,165,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="40,5,156,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Classes</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html">accumulated</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal5.html" title="Signal declaration.">sigc::signal5</a> template. <a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a5e64ba037f3567ab5dbb49811a447b2c"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a5e64ba037f3567ab5dbb49811a447b2c">signal</a> ()</td></tr>
+<tr class="separator:a5e64ba037f3567ab5dbb49811a447b2c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2f45d321526546618c56c1d5400507d2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a2f45d321526546618c56c1d5400507d2">signal</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:a2f45d321526546618c56c1d5400507d2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3447b5d32b839fa22ac7845ea448d2b4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a3447b5d32b839fa22ac7845ea448d2b4">signal</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:a3447b5d32b839fa22ac7845ea448d2b4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4d6e1453a0b4284cc19996e36cff5eef"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a4d6e1453a0b4284cc19996e36cff5eef">operator=</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:a4d6e1453a0b4284cc19996e36cff5eef"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a05a22fca63088154ba5c15b221e30760"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a05a22fca63088154ba5c15b221e30760">operator=</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:a05a22fca63088154ba5c15b221e30760"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal5"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal5')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td></tr>
+<tr class="memitem:af717d1a6fd8612da84dce33fe6640b7a inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#af717d1a6fd8612da84dce33fe6640b7a">signal5</a> ()</td></tr>
+<tr class="separator:af717d1a6fd8612da84dce33fe6640b7a inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7885861b9cdbacbe2d58a13cd96ec265 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a7885861b9cdbacbe2d58a13cd96ec265">signal5</a> (const <a class="el" href="classsigc_1_1signal5.html">signal5</a> & src)</td></tr>
+<tr class="separator:a7885861b9cdbacbe2d58a13cd96ec265 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af39141aeec9dc870dd28926202493de4 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#af39141aeec9dc870dd28926202493de4">signal5</a> (<a class="el" href="classsigc_1_1signal5.html">signal5</a> && src)</td></tr>
+<tr class="separator:af39141aeec9dc870dd28926202493de4 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a057789cc27a920700e240f8f3d78dd65 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#acee689b441305fcee098345729fc28f3">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a057789cc27a920700e240f8f3d78dd65">connect</a> (const <a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:a057789cc27a920700e240f8f3d78dd65 inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal5.html#a057789cc27a920700e240f8f3d78dd65">More...</a><br /></td></tr>
+<tr class="separator:a057789cc27a920700e240f8f3d78dd65 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a05cfed3d3e29158424bc810168d78153 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#acee689b441305fcee098345729fc28f3">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a05cfed3d3e29158424bc810168d78153">connect</a> (<a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:a05cfed3d3e29158424bc810168d78153 inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal5.html#a05cfed3d3e29158424bc810168d78153">More...</a><br /></td></tr>
+<tr class="separator:a05cfed3d3e29158424bc810168d78153 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8772fef879632c4ff45e82b4b00b0157 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:a8772fef879632c4ff45e82b4b00b0157 inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157">More...</a><br /></td></tr>
+<tr class="separator:a8772fef879632c4ff45e82b4b00b0157 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa6d2e202263e3879f0d3949612d7fcdf inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#aa6d2e202263e3879f0d3949612d7fcdf">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:aa6d2e202263e3879f0d3949612d7fcdf inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal5.html#aa6d2e202263e3879f0d3949612d7fcdf">More...</a><br /></td></tr>
+<tr class="separator:aa6d2e202263e3879f0d3949612d7fcdf inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7b01481c87d4ec9c03095e76cb502c24 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html">bound_const_mem_functor5</a>< <a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a>, <a class="el" href="classsigc_1_1signal5.html">signal5</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a7b01481c87d4ec9c03095e76cb502c24">make_slot</a> () const</td></tr>
+<tr class="memdesc:a7b01481c87d4ec9c03095e76cb502c24 inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal5.html#a7b01481c87d4ec9c03095e76cb502c24">More...</a><br /></td></tr>
+<tr class="separator:a7b01481c87d4ec9c03095e76cb502c24 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7a5bb7b92f49e99354caf50bfef16907 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a7a5bb7b92f49e99354caf50bfef16907">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:a7a5bb7b92f49e99354caf50bfef16907 inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal5.html#a7a5bb7b92f49e99354caf50bfef16907">More...</a><br /></td></tr>
+<tr class="separator:a7a5bb7b92f49e99354caf50bfef16907 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2c3d9a6d8b499da389672f44f8044ce6 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html">signal5</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a2c3d9a6d8b499da389672f44f8044ce6">operator=</a> (const <a class="el" href="classsigc_1_1signal5.html">signal5</a> & src)</td></tr>
+<tr class="separator:a2c3d9a6d8b499da389672f44f8044ce6 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5c652f8e549a2c555b79db8e8a05f407 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html">signal5</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a5c652f8e549a2c555b79db8e8a05f407">operator=</a> (<a class="el" href="classsigc_1_1signal5.html">signal5</a> && src)</td></tr>
+<tr class="separator:a5c652f8e549a2c555b79db8e8a05f407 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad6a4ae2a214d8710be6e36bb425587fc inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#a4c79ab227fc3b31b990e925636f7788e">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#ad6a4ae2a214d8710be6e36bb425587fc">slots</a> ()</td></tr>
+<tr class="memdesc:ad6a4ae2a214d8710be6e36bb425587fc inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal5.html#ad6a4ae2a214d8710be6e36bb425587fc">More...</a><br /></td></tr>
+<tr class="separator:ad6a4ae2a214d8710be6e36bb425587fc inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a32af276c9c56abbb0386f54262b40be5 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal5.html#a4c79ab227fc3b31b990e925636f7788e">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a32af276c9c56abbb0386f54262b40be5">slots</a> () const</td></tr>
+<tr class="memdesc:a32af276c9c56abbb0386f54262b40be5 inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal5.html#a32af276c9c56abbb0386f54262b40be5">More...</a><br /></td></tr>
+<tr class="separator:a32af276c9c56abbb0386f54262b40be5 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal5"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal5')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td></tr>
+<tr class="memitem:a17e79eed46f178a12d2751eddcf85290 inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a17e79eed46f178a12d2751eddcf85290">const_iterator</a></td></tr>
+<tr class="separator:a17e79eed46f178a12d2751eddcf85290 inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad5ba46907fe236e0cff806888696d569 inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#ad5ba46907fe236e0cff806888696d569">const_reverse_iterator</a></td></tr>
+<tr class="separator:ad5ba46907fe236e0cff806888696d569 inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7d77e5fa748b024842bf92e28cf0f4ab inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, <a class="el" href="structsigc_1_1nil.html">nil</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a7d77e5fa748b024842bf92e28cf0f4ab">emitter_type</a></td></tr>
+<tr class="separator:a7d77e5fa748b024842bf92e28cf0f4ab inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acee689b441305fcee098345729fc28f3 inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#acee689b441305fcee098345729fc28f3">iterator</a></td></tr>
+<tr class="separator:acee689b441305fcee098345729fc28f3 inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aceb959897dcf8e3c7209c283d4848b94 inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a></td></tr>
+<tr class="separator:aceb959897dcf8e3c7209c283d4848b94 inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab684cb9920d0f7949f28c03d50b58275 inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#ab684cb9920d0f7949f28c03d50b58275">reverse_iterator</a></td></tr>
+<tr class="separator:ab684cb9920d0f7949f28c03d50b58275 inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4c79ab227fc3b31b990e925636f7788e inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a4c79ab227fc3b31b990e925636f7788e">slot_list_type</a></td></tr>
+<tr class="separator:a4c79ab227fc3b31b990e925636f7788e inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae73737aad5d854c6466e8b13e7963b9e inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a></td></tr>
+<tr class="separator:ae73737aad5d854c6466e8b13e7963b9e inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5><br />
+class sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal5.html" title="Signal declaration.">sigc::signal5</a> template. </p>
+<p>See the base class for useful methods. This is the template specialization of the unnumbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> template for 5 argument(s).</p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000007">Deprecated:</a></b></dt><dd>Please use the syntax similar to that used by std::function<>: </dd></dl>
+<div class="fragment"><div class="line"><a class="code" href="classsigc_1_1slot.html">sigc::slot</a><void(<span class="keywordtype">bool</span>, <span class="keywordtype">int</span>)> some_slot;</div>
+<div class="ttc" id="aclasssigc_1_1slot_html"><div class="ttname"><a href="classsigc_1_1slot.html">sigc::slot</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::slot# templates.</div><div class="ttdef"><b>Definition:</b> slot.h:1645</div></div>
+</div><!-- fragment --> </div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a5e64ba037f3567ab5dbb49811a447b2c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5e64ba037f3567ab5dbb49811a447b2c">◆ </a></span>signal() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a2f45d321526546618c56c1d5400507d2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2f45d321526546618c56c1d5400507d2">◆ </a></span>signal() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a3447b5d32b839fa22ac7845ea448d2b4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3447b5d32b839fa22ac7845ea448d2b4">◆ </a></span>signal() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a4d6e1453a0b4284cc19996e36cff5eef"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4d6e1453a0b4284cc19996e36cff5eef">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a05a22fca63088154ba5c15b221e30760"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a05a22fca63088154ba5c15b221e30760">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a5fdb6df3cf74f5c96fb6319eef4d0a39">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a5c8d2d9c91a134650a52631d49ecdaac">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a3d2626edc726047c04c8fe5b9824b958">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a555ce030884fdf2bde788b75db01bedf">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a0aaf27875cdb8a0ae381372d98871ae1">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#acf3d1e6d6487c0ecc13ed3eab949eec7">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a31e8354263a3097bba9c63b8494143f0">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#aebcf1389e689b8d43ff739df118482bc">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a8523a4d47c3a6469fcc50da9977afdb8">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a84ee7d648bf622ec496127ceec819946">operator=</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a7e84970efac0339e7ebaaa46540ef0cc">operator=</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a05908db9c09a9c513529cd8b2106f913">signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil >::operator=</a>(const signal4 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#ab21da01af7c724bf0cf9df35ee9a70c1">signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil >::operator=</a>(signal4 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a1395da7d3283b0166af135193a4047c8">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a76731fb4092ef8d9b459c8c32c5433dc">signal</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a299bbe1b511723c6c854e516aaf0a926">signal</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a51f9443b48b006a65114bdd18d13cd4b">signal</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a2d469f516a9edac2b20d7f6cf46e821a">signal4</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a2d29b39c12c6c014ed7166190e9c8e22">signal4</a>(const signal4 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a2197974bac2b5e8e7b1c417580686e9e">signal4</a>(signal4 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a0ad0f56a43825c6d77d36dd2f06ef828">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#ae490f1a6802c40a4c3b12e1580520c88">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a35f2cebe3804d3e04d3253b7cc8d2a72">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#nested-classes">Classes</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal4.html" title="Signal declaration.">sigc::signal4</a> template.
+ <a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d3a462cf1a3aee09f94ea984d7d5fb39.png" border="0" usemap="#asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4_inherit__map" id="asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::signal4 template." alt="" coords="5,259,184,315"/>
+<area shape="rect" href="classsigc_1_1signal4.html" title=" " alt="" coords="5,155,184,211"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="28,80,161,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="37,5,153,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Classes</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html">accumulated</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal4.html" title="Signal declaration.">sigc::signal4</a> template. <a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a76731fb4092ef8d9b459c8c32c5433dc"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a76731fb4092ef8d9b459c8c32c5433dc">signal</a> ()</td></tr>
+<tr class="separator:a76731fb4092ef8d9b459c8c32c5433dc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a299bbe1b511723c6c854e516aaf0a926"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a299bbe1b511723c6c854e516aaf0a926">signal</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:a299bbe1b511723c6c854e516aaf0a926"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a51f9443b48b006a65114bdd18d13cd4b"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a51f9443b48b006a65114bdd18d13cd4b">signal</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:a51f9443b48b006a65114bdd18d13cd4b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a84ee7d648bf622ec496127ceec819946"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a84ee7d648bf622ec496127ceec819946">operator=</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:a84ee7d648bf622ec496127ceec819946"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7e84970efac0339e7ebaaa46540ef0cc"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a7e84970efac0339e7ebaaa46540ef0cc">operator=</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:a7e84970efac0339e7ebaaa46540ef0cc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal4"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal4')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td></tr>
+<tr class="memitem:a2d469f516a9edac2b20d7f6cf46e821a inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a2d469f516a9edac2b20d7f6cf46e821a">signal4</a> ()</td></tr>
+<tr class="separator:a2d469f516a9edac2b20d7f6cf46e821a inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2d29b39c12c6c014ed7166190e9c8e22 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a2d29b39c12c6c014ed7166190e9c8e22">signal4</a> (const <a class="el" href="classsigc_1_1signal4.html">signal4</a> & src)</td></tr>
+<tr class="separator:a2d29b39c12c6c014ed7166190e9c8e22 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2197974bac2b5e8e7b1c417580686e9e inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a2197974bac2b5e8e7b1c417580686e9e">signal4</a> (<a class="el" href="classsigc_1_1signal4.html">signal4</a> && src)</td></tr>
+<tr class="separator:a2197974bac2b5e8e7b1c417580686e9e inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5fdb6df3cf74f5c96fb6319eef4d0a39 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#a31e8354263a3097bba9c63b8494143f0">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a5fdb6df3cf74f5c96fb6319eef4d0a39">connect</a> (const <a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:a5fdb6df3cf74f5c96fb6319eef4d0a39 inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal4.html#a5fdb6df3cf74f5c96fb6319eef4d0a39">More...</a><br /></td></tr>
+<tr class="separator:a5fdb6df3cf74f5c96fb6319eef4d0a39 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5c8d2d9c91a134650a52631d49ecdaac inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#a31e8354263a3097bba9c63b8494143f0">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a5c8d2d9c91a134650a52631d49ecdaac">connect</a> (<a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:a5c8d2d9c91a134650a52631d49ecdaac inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal4.html#a5c8d2d9c91a134650a52631d49ecdaac">More...</a><br /></td></tr>
+<tr class="separator:a5c8d2d9c91a134650a52631d49ecdaac inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7774ba75b5e2391a6fe2841f8b3b0ef inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:aa7774ba75b5e2391a6fe2841f8b3b0ef inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef">More...</a><br /></td></tr>
+<tr class="separator:aa7774ba75b5e2391a6fe2841f8b3b0ef inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0aaf27875cdb8a0ae381372d98871ae1 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a0aaf27875cdb8a0ae381372d98871ae1">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:a0aaf27875cdb8a0ae381372d98871ae1 inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal4.html#a0aaf27875cdb8a0ae381372d98871ae1">More...</a><br /></td></tr>
+<tr class="separator:a0aaf27875cdb8a0ae381372d98871ae1 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebcf1389e689b8d43ff739df118482bc inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html">bound_const_mem_functor4</a>< <a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a>, <a class="el" href="classsigc_1_1signal4.html">signal4</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#aebcf1389e689b8d43ff739df118482bc">make_slot</a> () const</td></tr>
+<tr class="memdesc:aebcf1389e689b8d43ff739df118482bc inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal4.html#aebcf1389e689b8d43ff739df118482bc">More...</a><br /></td></tr>
+<tr class="separator:aebcf1389e689b8d43ff739df118482bc inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8523a4d47c3a6469fcc50da9977afdb8 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a8523a4d47c3a6469fcc50da9977afdb8">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:a8523a4d47c3a6469fcc50da9977afdb8 inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal4.html#a8523a4d47c3a6469fcc50da9977afdb8">More...</a><br /></td></tr>
+<tr class="separator:a8523a4d47c3a6469fcc50da9977afdb8 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a05908db9c09a9c513529cd8b2106f913 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html">signal4</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a05908db9c09a9c513529cd8b2106f913">operator=</a> (const <a class="el" href="classsigc_1_1signal4.html">signal4</a> & src)</td></tr>
+<tr class="separator:a05908db9c09a9c513529cd8b2106f913 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab21da01af7c724bf0cf9df35ee9a70c1 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html">signal4</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#ab21da01af7c724bf0cf9df35ee9a70c1">operator=</a> (<a class="el" href="classsigc_1_1signal4.html">signal4</a> && src)</td></tr>
+<tr class="separator:ab21da01af7c724bf0cf9df35ee9a70c1 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae490f1a6802c40a4c3b12e1580520c88 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#a0ad0f56a43825c6d77d36dd2f06ef828">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#ae490f1a6802c40a4c3b12e1580520c88">slots</a> ()</td></tr>
+<tr class="memdesc:ae490f1a6802c40a4c3b12e1580520c88 inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal4.html#ae490f1a6802c40a4c3b12e1580520c88">More...</a><br /></td></tr>
+<tr class="separator:ae490f1a6802c40a4c3b12e1580520c88 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a35f2cebe3804d3e04d3253b7cc8d2a72 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal4.html#a0ad0f56a43825c6d77d36dd2f06ef828">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a35f2cebe3804d3e04d3253b7cc8d2a72">slots</a> () const</td></tr>
+<tr class="memdesc:a35f2cebe3804d3e04d3253b7cc8d2a72 inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal4.html#a35f2cebe3804d3e04d3253b7cc8d2a72">More...</a><br /></td></tr>
+<tr class="separator:a35f2cebe3804d3e04d3253b7cc8d2a72 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal4"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal4')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td></tr>
+<tr class="memitem:a3d2626edc726047c04c8fe5b9824b958 inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a3d2626edc726047c04c8fe5b9824b958">const_iterator</a></td></tr>
+<tr class="separator:a3d2626edc726047c04c8fe5b9824b958 inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a555ce030884fdf2bde788b75db01bedf inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a555ce030884fdf2bde788b75db01bedf">const_reverse_iterator</a></td></tr>
+<tr class="separator:a555ce030884fdf2bde788b75db01bedf inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acf3d1e6d6487c0ecc13ed3eab949eec7 inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, <a class="el" href="structsigc_1_1nil.html">nil</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#acf3d1e6d6487c0ecc13ed3eab949eec7">emitter_type</a></td></tr>
+<tr class="separator:acf3d1e6d6487c0ecc13ed3eab949eec7 inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a31e8354263a3097bba9c63b8494143f0 inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a31e8354263a3097bba9c63b8494143f0">iterator</a></td></tr>
+<tr class="separator:a31e8354263a3097bba9c63b8494143f0 inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af32418ba14001a63d28af08abb7407f0 inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a></td></tr>
+<tr class="separator:af32418ba14001a63d28af08abb7407f0 inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1395da7d3283b0166af135193a4047c8 inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a1395da7d3283b0166af135193a4047c8">reverse_iterator</a></td></tr>
+<tr class="separator:a1395da7d3283b0166af135193a4047c8 inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0ad0f56a43825c6d77d36dd2f06ef828 inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a0ad0f56a43825c6d77d36dd2f06ef828">slot_list_type</a></td></tr>
+<tr class="separator:a0ad0f56a43825c6d77d36dd2f06ef828 inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa93452fe80399184444d094786be851c inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a></td></tr>
+<tr class="separator:aa93452fe80399184444d094786be851c inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4><br />
+class sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal4.html" title="Signal declaration.">sigc::signal4</a> template. </p>
+<p>See the base class for useful methods. This is the template specialization of the unnumbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> template for 4 argument(s).</p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000006">Deprecated:</a></b></dt><dd>Please use the syntax similar to that used by std::function<>: </dd></dl>
+<div class="fragment"><div class="line"><a class="code" href="classsigc_1_1slot.html">sigc::slot</a><void(<span class="keywordtype">bool</span>, <span class="keywordtype">int</span>)> some_slot;</div>
+<div class="ttc" id="aclasssigc_1_1slot_html"><div class="ttname"><a href="classsigc_1_1slot.html">sigc::slot</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::slot# templates.</div><div class="ttdef"><b>Definition:</b> slot.h:1645</div></div>
+</div><!-- fragment --> </div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a76731fb4092ef8d9b459c8c32c5433dc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a76731fb4092ef8d9b459c8c32c5433dc">◆ </a></span>signal() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a299bbe1b511723c6c854e516aaf0a926"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a299bbe1b511723c6c854e516aaf0a926">◆ </a></span>signal() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a51f9443b48b006a65114bdd18d13cd4b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a51f9443b48b006a65114bdd18d13cd4b">◆ </a></span>signal() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a84ee7d648bf622ec496127ceec819946"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a84ee7d648bf622ec496127ceec819946">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a7e84970efac0339e7ebaaa46540ef0cc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7e84970efac0339e7ebaaa46540ef0cc">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::accumulated< T_accumulator > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::accumulated< T_accumulator ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html#a994494b04443cda13eef81e13321db83">accumulated</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html#a2d21852efcef1d59cc96c8c873e6ce37">accumulated</a>(const accumulated & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a5fdb6df3cf74f5c96fb6319eef4d0a39">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a5c8d2d9c91a134650a52631d49ecdaac">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a3d2626edc726047c04c8fe5b9824b958">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a555ce030884fdf2bde788b75db01bedf">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a0aaf27875cdb8a0ae381372d98871ae1">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#acf3d1e6d6487c0ecc13ed3eab949eec7">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a31e8354263a3097bba9c63b8494143f0">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#aebcf1389e689b8d43ff739df118482bc">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a8523a4d47c3a6469fcc50da9977afdb8">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a05908db9c09a9c513529cd8b2106f913">operator=</a>(const signal4 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#ab21da01af7c724bf0cf9df35ee9a70c1">operator=</a>(signal4 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a1395da7d3283b0166af135193a4047c8">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a2d469f516a9edac2b20d7f6cf46e821a">signal4</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a2d29b39c12c6c014ed7166190e9c8e22">signal4</a>(const signal4 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a2197974bac2b5e8e7b1c417580686e9e">signal4</a>(signal4 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a0ad0f56a43825c6d77d36dd2f06ef828">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#ae490f1a6802c40a4c3b12e1580520c88">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a35f2cebe3804d3e04d3253b7cc8d2a72">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::accumulated< T_accumulator >" name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::accumulated< T_accumulator >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::signal4 template." alt="" coords="5,259,245,329"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal4.html" title=" " alt="" coords="31,155,220,211"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="59,80,192,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="67,5,183,32"/>
+</map>
--- /dev/null
+217736d8a232a9746439faadfb5bef19
\ No newline at end of file
--- /dev/null
+<map id="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >" name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::signal4 template." alt="" coords="5,259,184,315"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal4.html" title=" " alt="" coords="5,155,184,211"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="28,80,161,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="37,5,153,32"/>
+</map>
--- /dev/null
+ce9f070d75b950145415692fcb052e6b
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::accumulated< T_accumulator > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0ad52bc79df5ba2b4d7e5b497ba915039.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::accumulated< T_accumulator > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal4.html" title="Signal declaration.">sigc::signal4</a> template.
+ <a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::accumulated< T_accumulator >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0b160353f4ad061f559297e128c4d0646.png" border="0" usemap="#asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" id="asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::signal4 template." alt="" coords="5,259,245,329"/>
+<area shape="rect" href="classsigc_1_1signal4.html" title=" " alt="" coords="31,155,220,211"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="59,80,192,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="67,5,183,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a994494b04443cda13eef81e13321db83"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html#a994494b04443cda13eef81e13321db83">accumulated</a> ()</td></tr>
+<tr class="separator:a994494b04443cda13eef81e13321db83"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2d21852efcef1d59cc96c8c873e6ce37"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html#a2d21852efcef1d59cc96c8c873e6ce37">accumulated</a> (const accumulated & src)</td></tr>
+<tr class="separator:a2d21852efcef1d59cc96c8c873e6ce37"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal4"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal4')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td></tr>
+<tr class="memitem:a2d469f516a9edac2b20d7f6cf46e821a inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a2d469f516a9edac2b20d7f6cf46e821a">signal4</a> ()</td></tr>
+<tr class="separator:a2d469f516a9edac2b20d7f6cf46e821a inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2d29b39c12c6c014ed7166190e9c8e22 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a2d29b39c12c6c014ed7166190e9c8e22">signal4</a> (const <a class="el" href="classsigc_1_1signal4.html">signal4</a> & src)</td></tr>
+<tr class="separator:a2d29b39c12c6c014ed7166190e9c8e22 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2197974bac2b5e8e7b1c417580686e9e inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a2197974bac2b5e8e7b1c417580686e9e">signal4</a> (<a class="el" href="classsigc_1_1signal4.html">signal4</a> && src)</td></tr>
+<tr class="separator:a2197974bac2b5e8e7b1c417580686e9e inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5fdb6df3cf74f5c96fb6319eef4d0a39 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#a31e8354263a3097bba9c63b8494143f0">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a5fdb6df3cf74f5c96fb6319eef4d0a39">connect</a> (const <a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:a5fdb6df3cf74f5c96fb6319eef4d0a39 inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal4.html#a5fdb6df3cf74f5c96fb6319eef4d0a39">More...</a><br /></td></tr>
+<tr class="separator:a5fdb6df3cf74f5c96fb6319eef4d0a39 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5c8d2d9c91a134650a52631d49ecdaac inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#a31e8354263a3097bba9c63b8494143f0">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a5c8d2d9c91a134650a52631d49ecdaac">connect</a> (<a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:a5c8d2d9c91a134650a52631d49ecdaac inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal4.html#a5c8d2d9c91a134650a52631d49ecdaac">More...</a><br /></td></tr>
+<tr class="separator:a5c8d2d9c91a134650a52631d49ecdaac inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7774ba75b5e2391a6fe2841f8b3b0ef inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:aa7774ba75b5e2391a6fe2841f8b3b0ef inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef">More...</a><br /></td></tr>
+<tr class="separator:aa7774ba75b5e2391a6fe2841f8b3b0ef inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0aaf27875cdb8a0ae381372d98871ae1 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a0aaf27875cdb8a0ae381372d98871ae1">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:a0aaf27875cdb8a0ae381372d98871ae1 inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal4.html#a0aaf27875cdb8a0ae381372d98871ae1">More...</a><br /></td></tr>
+<tr class="separator:a0aaf27875cdb8a0ae381372d98871ae1 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebcf1389e689b8d43ff739df118482bc inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html">bound_const_mem_functor4</a>< <a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a>, <a class="el" href="classsigc_1_1signal4.html">signal4</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#aebcf1389e689b8d43ff739df118482bc">make_slot</a> () const</td></tr>
+<tr class="memdesc:aebcf1389e689b8d43ff739df118482bc inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal4.html#aebcf1389e689b8d43ff739df118482bc">More...</a><br /></td></tr>
+<tr class="separator:aebcf1389e689b8d43ff739df118482bc inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8523a4d47c3a6469fcc50da9977afdb8 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a8523a4d47c3a6469fcc50da9977afdb8">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:a8523a4d47c3a6469fcc50da9977afdb8 inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal4.html#a8523a4d47c3a6469fcc50da9977afdb8">More...</a><br /></td></tr>
+<tr class="separator:a8523a4d47c3a6469fcc50da9977afdb8 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a05908db9c09a9c513529cd8b2106f913 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html">signal4</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a05908db9c09a9c513529cd8b2106f913">operator=</a> (const <a class="el" href="classsigc_1_1signal4.html">signal4</a> & src)</td></tr>
+<tr class="separator:a05908db9c09a9c513529cd8b2106f913 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab21da01af7c724bf0cf9df35ee9a70c1 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html">signal4</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#ab21da01af7c724bf0cf9df35ee9a70c1">operator=</a> (<a class="el" href="classsigc_1_1signal4.html">signal4</a> && src)</td></tr>
+<tr class="separator:ab21da01af7c724bf0cf9df35ee9a70c1 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae490f1a6802c40a4c3b12e1580520c88 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#a0ad0f56a43825c6d77d36dd2f06ef828">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#ae490f1a6802c40a4c3b12e1580520c88">slots</a> ()</td></tr>
+<tr class="memdesc:ae490f1a6802c40a4c3b12e1580520c88 inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal4.html#ae490f1a6802c40a4c3b12e1580520c88">More...</a><br /></td></tr>
+<tr class="separator:ae490f1a6802c40a4c3b12e1580520c88 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a35f2cebe3804d3e04d3253b7cc8d2a72 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal4.html#a0ad0f56a43825c6d77d36dd2f06ef828">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a35f2cebe3804d3e04d3253b7cc8d2a72">slots</a> () const</td></tr>
+<tr class="memdesc:a35f2cebe3804d3e04d3253b7cc8d2a72 inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal4.html#a35f2cebe3804d3e04d3253b7cc8d2a72">More...</a><br /></td></tr>
+<tr class="separator:a35f2cebe3804d3e04d3253b7cc8d2a72 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal4"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal4')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td></tr>
+<tr class="memitem:a3d2626edc726047c04c8fe5b9824b958 inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a3d2626edc726047c04c8fe5b9824b958">const_iterator</a></td></tr>
+<tr class="separator:a3d2626edc726047c04c8fe5b9824b958 inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a555ce030884fdf2bde788b75db01bedf inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a555ce030884fdf2bde788b75db01bedf">const_reverse_iterator</a></td></tr>
+<tr class="separator:a555ce030884fdf2bde788b75db01bedf inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acf3d1e6d6487c0ecc13ed3eab949eec7 inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#acf3d1e6d6487c0ecc13ed3eab949eec7">emitter_type</a></td></tr>
+<tr class="separator:acf3d1e6d6487c0ecc13ed3eab949eec7 inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a31e8354263a3097bba9c63b8494143f0 inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a31e8354263a3097bba9c63b8494143f0">iterator</a></td></tr>
+<tr class="separator:a31e8354263a3097bba9c63b8494143f0 inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af32418ba14001a63d28af08abb7407f0 inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a></td></tr>
+<tr class="separator:af32418ba14001a63d28af08abb7407f0 inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1395da7d3283b0166af135193a4047c8 inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a1395da7d3283b0166af135193a4047c8">reverse_iterator</a></td></tr>
+<tr class="separator:a1395da7d3283b0166af135193a4047c8 inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0ad0f56a43825c6d77d36dd2f06ef828 inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a0ad0f56a43825c6d77d36dd2f06ef828">slot_list_type</a></td></tr>
+<tr class="separator:a0ad0f56a43825c6d77d36dd2f06ef828 inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa93452fe80399184444d094786be851c inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a></td></tr>
+<tr class="separator:aa93452fe80399184444d094786be851c inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4><br />
+template <class T_accumulator><br />
+class sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::accumulated< T_accumulator ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal4.html" title="Signal declaration.">sigc::signal4</a> template. </p>
+<p>Like <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> but the additional template parameter <em>T_accumulator</em> defines the accumulator type that should be used. </p>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a994494b04443cda13eef81e13321db83"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a994494b04443cda13eef81e13321db83">◆ </a></span>accumulated() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a2d21852efcef1d59cc96c8c873e6ce37"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2d21852efcef1d59cc96c8c873e6ce37">◆ </a></span>accumulated() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramtype">const accumulated & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::accumulated< T_accumulator >" name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::accumulated< T_accumulator >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::signal3 template." alt="" coords="5,259,227,329"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal3.html" title=" " alt="" coords="27,155,205,211"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="49,80,183,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="58,5,174,32"/>
+</map>
--- /dev/null
+9a513f3b426be14d10a8b665f7923aff
\ No newline at end of file
--- /dev/null
+<map id="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >" name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::signal3 template." alt="" coords="5,259,184,315"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal3.html" title=" " alt="" coords="5,155,184,211"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="28,80,161,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="37,5,153,32"/>
+</map>
--- /dev/null
+64eb85d484d4e3b9944833d9035a692d
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::accumulated< T_accumulator > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::accumulated< T_accumulator ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html#a86aae36f669ce2f9d7f1f0ac9a696f6c">accumulated</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html#ab20d2ddd7330aa974d61ddec753413b6">accumulated</a>(const accumulated & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a3eae0b3796b2736be847f33a5124aacd">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#ad71389c6d6ea60e745897579b3344d00">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a60e1ef95f82cd8981d61576d1e3f8e94">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a4ba3eb58c4c5ac2c25f49c48fd0af264">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a97ff4f22c97920a81e3f27aa5d39ba99">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#adf54ec96c5fb78d4c8b7fc032a1937ad">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a8029a48126a2018947a2b6680ddabe6b">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a332be8eb0ee22c11a2e1d140ca1bc2df">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#aa7ae5338d6a883a28c61ff202e43547f">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a0c398a25051e920bc4338f35b4bf7df6">operator=</a>(const signal3 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#abafd9fe17f2b9b18e25eb0293e9e8bfd">operator=</a>(signal3 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#acc453f0d5fc7f277494b2d6e737f6f68">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a52731959f272612fd6abfe8850c5c8cf">signal3</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#afe2c4320927b403b011a2538317e6c70">signal3</a>(const signal3 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#acd69c2a1d993f0b8993f82998f76020d">signal3</a>(signal3 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a3bc0616e7ac933e702a889a2a84e92d4">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#ab9606b708078956a758b81503f956bee">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a742eb282312187bf8ee6992df1114781">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::accumulated< T_accumulator > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01756aafa66a891f219b67f866edb12f89.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::accumulated< T_accumulator > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal3.html" title="Signal declaration.">sigc::signal3</a> template.
+ <a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::accumulated< T_accumulator >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_011e4fe3321f9150dc130b7a3b2213423b.png" border="0" usemap="#asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" id="asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::signal3 template." alt="" coords="5,259,227,329"/>
+<area shape="rect" href="classsigc_1_1signal3.html" title=" " alt="" coords="27,155,205,211"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="49,80,183,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="58,5,174,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a86aae36f669ce2f9d7f1f0ac9a696f6c"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html#a86aae36f669ce2f9d7f1f0ac9a696f6c">accumulated</a> ()</td></tr>
+<tr class="separator:a86aae36f669ce2f9d7f1f0ac9a696f6c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab20d2ddd7330aa974d61ddec753413b6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html#ab20d2ddd7330aa974d61ddec753413b6">accumulated</a> (const accumulated & src)</td></tr>
+<tr class="separator:ab20d2ddd7330aa974d61ddec753413b6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal3"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal3')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td></tr>
+<tr class="memitem:a52731959f272612fd6abfe8850c5c8cf inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a52731959f272612fd6abfe8850c5c8cf">signal3</a> ()</td></tr>
+<tr class="separator:a52731959f272612fd6abfe8850c5c8cf inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afe2c4320927b403b011a2538317e6c70 inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#afe2c4320927b403b011a2538317e6c70">signal3</a> (const <a class="el" href="classsigc_1_1signal3.html">signal3</a> & src)</td></tr>
+<tr class="separator:afe2c4320927b403b011a2538317e6c70 inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acd69c2a1d993f0b8993f82998f76020d inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#acd69c2a1d993f0b8993f82998f76020d">signal3</a> (<a class="el" href="classsigc_1_1signal3.html">signal3</a> && src)</td></tr>
+<tr class="separator:acd69c2a1d993f0b8993f82998f76020d inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3eae0b3796b2736be847f33a5124aacd inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a8029a48126a2018947a2b6680ddabe6b">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a3eae0b3796b2736be847f33a5124aacd">connect</a> (const <a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:a3eae0b3796b2736be847f33a5124aacd inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal3.html#a3eae0b3796b2736be847f33a5124aacd">More...</a><br /></td></tr>
+<tr class="separator:a3eae0b3796b2736be847f33a5124aacd inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad71389c6d6ea60e745897579b3344d00 inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a8029a48126a2018947a2b6680ddabe6b">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#ad71389c6d6ea60e745897579b3344d00">connect</a> (<a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:ad71389c6d6ea60e745897579b3344d00 inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal3.html#ad71389c6d6ea60e745897579b3344d00">More...</a><br /></td></tr>
+<tr class="separator:ad71389c6d6ea60e745897579b3344d00 inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8592e22e3780f2cdf19a568a8a116bbb inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:a8592e22e3780f2cdf19a568a8a116bbb inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb">More...</a><br /></td></tr>
+<tr class="separator:a8592e22e3780f2cdf19a568a8a116bbb inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a97ff4f22c97920a81e3f27aa5d39ba99 inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a97ff4f22c97920a81e3f27aa5d39ba99">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:a97ff4f22c97920a81e3f27aa5d39ba99 inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal3.html#a97ff4f22c97920a81e3f27aa5d39ba99">More...</a><br /></td></tr>
+<tr class="separator:a97ff4f22c97920a81e3f27aa5d39ba99 inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a332be8eb0ee22c11a2e1d140ca1bc2df inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html">bound_const_mem_functor3</a>< <a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a>, <a class="el" href="classsigc_1_1signal3.html">signal3</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a332be8eb0ee22c11a2e1d140ca1bc2df">make_slot</a> () const</td></tr>
+<tr class="memdesc:a332be8eb0ee22c11a2e1d140ca1bc2df inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal3.html#a332be8eb0ee22c11a2e1d140ca1bc2df">More...</a><br /></td></tr>
+<tr class="separator:a332be8eb0ee22c11a2e1d140ca1bc2df inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7ae5338d6a883a28c61ff202e43547f inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#aa7ae5338d6a883a28c61ff202e43547f">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:aa7ae5338d6a883a28c61ff202e43547f inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal3.html#aa7ae5338d6a883a28c61ff202e43547f">More...</a><br /></td></tr>
+<tr class="separator:aa7ae5338d6a883a28c61ff202e43547f inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0c398a25051e920bc4338f35b4bf7df6 inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html">signal3</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a0c398a25051e920bc4338f35b4bf7df6">operator=</a> (const <a class="el" href="classsigc_1_1signal3.html">signal3</a> & src)</td></tr>
+<tr class="separator:a0c398a25051e920bc4338f35b4bf7df6 inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abafd9fe17f2b9b18e25eb0293e9e8bfd inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html">signal3</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#abafd9fe17f2b9b18e25eb0293e9e8bfd">operator=</a> (<a class="el" href="classsigc_1_1signal3.html">signal3</a> && src)</td></tr>
+<tr class="separator:abafd9fe17f2b9b18e25eb0293e9e8bfd inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab9606b708078956a758b81503f956bee inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a3bc0616e7ac933e702a889a2a84e92d4">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#ab9606b708078956a758b81503f956bee">slots</a> ()</td></tr>
+<tr class="memdesc:ab9606b708078956a758b81503f956bee inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal3.html#ab9606b708078956a758b81503f956bee">More...</a><br /></td></tr>
+<tr class="separator:ab9606b708078956a758b81503f956bee inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a742eb282312187bf8ee6992df1114781 inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal3.html#a3bc0616e7ac933e702a889a2a84e92d4">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a742eb282312187bf8ee6992df1114781">slots</a> () const</td></tr>
+<tr class="memdesc:a742eb282312187bf8ee6992df1114781 inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal3.html#a742eb282312187bf8ee6992df1114781">More...</a><br /></td></tr>
+<tr class="separator:a742eb282312187bf8ee6992df1114781 inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal3"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal3')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td></tr>
+<tr class="memitem:a60e1ef95f82cd8981d61576d1e3f8e94 inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a60e1ef95f82cd8981d61576d1e3f8e94">const_iterator</a></td></tr>
+<tr class="separator:a60e1ef95f82cd8981d61576d1e3f8e94 inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4ba3eb58c4c5ac2c25f49c48fd0af264 inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a4ba3eb58c4c5ac2c25f49c48fd0af264">const_reverse_iterator</a></td></tr>
+<tr class="separator:a4ba3eb58c4c5ac2c25f49c48fd0af264 inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adf54ec96c5fb78d4c8b7fc032a1937ad inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#adf54ec96c5fb78d4c8b7fc032a1937ad">emitter_type</a></td></tr>
+<tr class="separator:adf54ec96c5fb78d4c8b7fc032a1937ad inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8029a48126a2018947a2b6680ddabe6b inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a8029a48126a2018947a2b6680ddabe6b">iterator</a></td></tr>
+<tr class="separator:a8029a48126a2018947a2b6680ddabe6b inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a57c79755fc4c4b04196a9bf6742a0cc6 inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a></td></tr>
+<tr class="separator:a57c79755fc4c4b04196a9bf6742a0cc6 inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acc453f0d5fc7f277494b2d6e737f6f68 inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#acc453f0d5fc7f277494b2d6e737f6f68">reverse_iterator</a></td></tr>
+<tr class="separator:acc453f0d5fc7f277494b2d6e737f6f68 inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3bc0616e7ac933e702a889a2a84e92d4 inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a3bc0616e7ac933e702a889a2a84e92d4">slot_list_type</a></td></tr>
+<tr class="separator:a3bc0616e7ac933e702a889a2a84e92d4 inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afe37478128b40fb4efedcd3c0eb05b6b inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2, T_arg3)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a></td></tr>
+<tr class="separator:afe37478128b40fb4efedcd3c0eb05b6b inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3><br />
+template <class T_accumulator><br />
+class sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::accumulated< T_accumulator ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal3.html" title="Signal declaration.">sigc::signal3</a> template. </p>
+<p>Like <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> but the additional template parameter <em>T_accumulator</em> defines the accumulator type that should be used. </p>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a86aae36f669ce2f9d7f1f0ac9a696f6c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a86aae36f669ce2f9d7f1f0ac9a696f6c">◆ </a></span>accumulated() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ab20d2ddd7330aa974d61ddec753413b6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab20d2ddd7330aa974d61ddec753413b6">◆ </a></span>accumulated() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramtype">const accumulated & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a3eae0b3796b2736be847f33a5124aacd">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#ad71389c6d6ea60e745897579b3344d00">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a60e1ef95f82cd8981d61576d1e3f8e94">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a4ba3eb58c4c5ac2c25f49c48fd0af264">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a97ff4f22c97920a81e3f27aa5d39ba99">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#adf54ec96c5fb78d4c8b7fc032a1937ad">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a8029a48126a2018947a2b6680ddabe6b">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a332be8eb0ee22c11a2e1d140ca1bc2df">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#aa7ae5338d6a883a28c61ff202e43547f">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a706478aa21230e1b6ff4347f87efb0dc">operator=</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a8a0166f439840b854ab3253fa831bb03">operator=</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a0c398a25051e920bc4338f35b4bf7df6">signal3< T_return, T_arg1, T_arg2, T_arg3, nil >::operator=</a>(const signal3 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#abafd9fe17f2b9b18e25eb0293e9e8bfd">signal3< T_return, T_arg1, T_arg2, T_arg3, nil >::operator=</a>(signal3 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#acc453f0d5fc7f277494b2d6e737f6f68">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a3866d625025ecae063d59e81f86ec836">signal</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a80e31f482db26fc380264b7dea1041d7">signal</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a84d26ae312afec80b6a921894a52e9a8">signal</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a52731959f272612fd6abfe8850c5c8cf">signal3</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#afe2c4320927b403b011a2538317e6c70">signal3</a>(const signal3 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#acd69c2a1d993f0b8993f82998f76020d">signal3</a>(signal3 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a3bc0616e7ac933e702a889a2a84e92d4">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#ab9606b708078956a758b81503f956bee">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a742eb282312187bf8ee6992df1114781">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#nested-classes">Classes</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal3.html" title="Signal declaration.">sigc::signal3</a> template.
+ <a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_014f61314713a22a7e37f830f31ddcbf93.png" border="0" usemap="#asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map" id="asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::signal3 template." alt="" coords="5,259,184,315"/>
+<area shape="rect" href="classsigc_1_1signal3.html" title=" " alt="" coords="5,155,184,211"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="28,80,161,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="37,5,153,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Classes</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html">accumulated</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal3.html" title="Signal declaration.">sigc::signal3</a> template. <a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a3866d625025ecae063d59e81f86ec836"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a3866d625025ecae063d59e81f86ec836">signal</a> ()</td></tr>
+<tr class="separator:a3866d625025ecae063d59e81f86ec836"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a80e31f482db26fc380264b7dea1041d7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a80e31f482db26fc380264b7dea1041d7">signal</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:a80e31f482db26fc380264b7dea1041d7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a84d26ae312afec80b6a921894a52e9a8"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a84d26ae312afec80b6a921894a52e9a8">signal</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:a84d26ae312afec80b6a921894a52e9a8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a706478aa21230e1b6ff4347f87efb0dc"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a706478aa21230e1b6ff4347f87efb0dc">operator=</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:a706478aa21230e1b6ff4347f87efb0dc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8a0166f439840b854ab3253fa831bb03"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a8a0166f439840b854ab3253fa831bb03">operator=</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:a8a0166f439840b854ab3253fa831bb03"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal3"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal3')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td></tr>
+<tr class="memitem:a52731959f272612fd6abfe8850c5c8cf inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a52731959f272612fd6abfe8850c5c8cf">signal3</a> ()</td></tr>
+<tr class="separator:a52731959f272612fd6abfe8850c5c8cf inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afe2c4320927b403b011a2538317e6c70 inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#afe2c4320927b403b011a2538317e6c70">signal3</a> (const <a class="el" href="classsigc_1_1signal3.html">signal3</a> & src)</td></tr>
+<tr class="separator:afe2c4320927b403b011a2538317e6c70 inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acd69c2a1d993f0b8993f82998f76020d inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#acd69c2a1d993f0b8993f82998f76020d">signal3</a> (<a class="el" href="classsigc_1_1signal3.html">signal3</a> && src)</td></tr>
+<tr class="separator:acd69c2a1d993f0b8993f82998f76020d inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3eae0b3796b2736be847f33a5124aacd inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a8029a48126a2018947a2b6680ddabe6b">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a3eae0b3796b2736be847f33a5124aacd">connect</a> (const <a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:a3eae0b3796b2736be847f33a5124aacd inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal3.html#a3eae0b3796b2736be847f33a5124aacd">More...</a><br /></td></tr>
+<tr class="separator:a3eae0b3796b2736be847f33a5124aacd inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad71389c6d6ea60e745897579b3344d00 inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a8029a48126a2018947a2b6680ddabe6b">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#ad71389c6d6ea60e745897579b3344d00">connect</a> (<a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:ad71389c6d6ea60e745897579b3344d00 inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal3.html#ad71389c6d6ea60e745897579b3344d00">More...</a><br /></td></tr>
+<tr class="separator:ad71389c6d6ea60e745897579b3344d00 inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8592e22e3780f2cdf19a568a8a116bbb inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:a8592e22e3780f2cdf19a568a8a116bbb inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb">More...</a><br /></td></tr>
+<tr class="separator:a8592e22e3780f2cdf19a568a8a116bbb inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a97ff4f22c97920a81e3f27aa5d39ba99 inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a97ff4f22c97920a81e3f27aa5d39ba99">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:a97ff4f22c97920a81e3f27aa5d39ba99 inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal3.html#a97ff4f22c97920a81e3f27aa5d39ba99">More...</a><br /></td></tr>
+<tr class="separator:a97ff4f22c97920a81e3f27aa5d39ba99 inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a332be8eb0ee22c11a2e1d140ca1bc2df inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html">bound_const_mem_functor3</a>< <a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a>, <a class="el" href="classsigc_1_1signal3.html">signal3</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a332be8eb0ee22c11a2e1d140ca1bc2df">make_slot</a> () const</td></tr>
+<tr class="memdesc:a332be8eb0ee22c11a2e1d140ca1bc2df inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal3.html#a332be8eb0ee22c11a2e1d140ca1bc2df">More...</a><br /></td></tr>
+<tr class="separator:a332be8eb0ee22c11a2e1d140ca1bc2df inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7ae5338d6a883a28c61ff202e43547f inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#aa7ae5338d6a883a28c61ff202e43547f">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:aa7ae5338d6a883a28c61ff202e43547f inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal3.html#aa7ae5338d6a883a28c61ff202e43547f">More...</a><br /></td></tr>
+<tr class="separator:aa7ae5338d6a883a28c61ff202e43547f inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0c398a25051e920bc4338f35b4bf7df6 inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html">signal3</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a0c398a25051e920bc4338f35b4bf7df6">operator=</a> (const <a class="el" href="classsigc_1_1signal3.html">signal3</a> & src)</td></tr>
+<tr class="separator:a0c398a25051e920bc4338f35b4bf7df6 inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abafd9fe17f2b9b18e25eb0293e9e8bfd inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html">signal3</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#abafd9fe17f2b9b18e25eb0293e9e8bfd">operator=</a> (<a class="el" href="classsigc_1_1signal3.html">signal3</a> && src)</td></tr>
+<tr class="separator:abafd9fe17f2b9b18e25eb0293e9e8bfd inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab9606b708078956a758b81503f956bee inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a3bc0616e7ac933e702a889a2a84e92d4">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#ab9606b708078956a758b81503f956bee">slots</a> ()</td></tr>
+<tr class="memdesc:ab9606b708078956a758b81503f956bee inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal3.html#ab9606b708078956a758b81503f956bee">More...</a><br /></td></tr>
+<tr class="separator:ab9606b708078956a758b81503f956bee inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a742eb282312187bf8ee6992df1114781 inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal3.html#a3bc0616e7ac933e702a889a2a84e92d4">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a742eb282312187bf8ee6992df1114781">slots</a> () const</td></tr>
+<tr class="memdesc:a742eb282312187bf8ee6992df1114781 inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal3.html#a742eb282312187bf8ee6992df1114781">More...</a><br /></td></tr>
+<tr class="separator:a742eb282312187bf8ee6992df1114781 inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal3"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal3')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td></tr>
+<tr class="memitem:a60e1ef95f82cd8981d61576d1e3f8e94 inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a60e1ef95f82cd8981d61576d1e3f8e94">const_iterator</a></td></tr>
+<tr class="separator:a60e1ef95f82cd8981d61576d1e3f8e94 inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4ba3eb58c4c5ac2c25f49c48fd0af264 inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a4ba3eb58c4c5ac2c25f49c48fd0af264">const_reverse_iterator</a></td></tr>
+<tr class="separator:a4ba3eb58c4c5ac2c25f49c48fd0af264 inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adf54ec96c5fb78d4c8b7fc032a1937ad inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit3< T_return, T_arg1, T_arg2, T_arg3, <a class="el" href="structsigc_1_1nil.html">nil</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#adf54ec96c5fb78d4c8b7fc032a1937ad">emitter_type</a></td></tr>
+<tr class="separator:adf54ec96c5fb78d4c8b7fc032a1937ad inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8029a48126a2018947a2b6680ddabe6b inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a8029a48126a2018947a2b6680ddabe6b">iterator</a></td></tr>
+<tr class="separator:a8029a48126a2018947a2b6680ddabe6b inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a57c79755fc4c4b04196a9bf6742a0cc6 inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a></td></tr>
+<tr class="separator:a57c79755fc4c4b04196a9bf6742a0cc6 inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acc453f0d5fc7f277494b2d6e737f6f68 inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#acc453f0d5fc7f277494b2d6e737f6f68">reverse_iterator</a></td></tr>
+<tr class="separator:acc453f0d5fc7f277494b2d6e737f6f68 inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3bc0616e7ac933e702a889a2a84e92d4 inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a3bc0616e7ac933e702a889a2a84e92d4">slot_list_type</a></td></tr>
+<tr class="separator:a3bc0616e7ac933e702a889a2a84e92d4 inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afe37478128b40fb4efedcd3c0eb05b6b inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2, T_arg3)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a></td></tr>
+<tr class="separator:afe37478128b40fb4efedcd3c0eb05b6b inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3><br />
+class sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal3.html" title="Signal declaration.">sigc::signal3</a> template. </p>
+<p>See the base class for useful methods. This is the template specialization of the unnumbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> template for 3 argument(s).</p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000005">Deprecated:</a></b></dt><dd>Please use the syntax similar to that used by std::function<>: </dd></dl>
+<div class="fragment"><div class="line"><a class="code" href="classsigc_1_1slot.html">sigc::slot</a><void(<span class="keywordtype">bool</span>, <span class="keywordtype">int</span>)> some_slot;</div>
+<div class="ttc" id="aclasssigc_1_1slot_html"><div class="ttname"><a href="classsigc_1_1slot.html">sigc::slot</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::slot# templates.</div><div class="ttdef"><b>Definition:</b> slot.h:1645</div></div>
+</div><!-- fragment --> </div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a3866d625025ecae063d59e81f86ec836"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3866d625025ecae063d59e81f86ec836">◆ </a></span>signal() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a80e31f482db26fc380264b7dea1041d7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a80e31f482db26fc380264b7dea1041d7">◆ </a></span>signal() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, T_arg1, T_arg2, T_arg3, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a84d26ae312afec80b6a921894a52e9a8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a84d26ae312afec80b6a921894a52e9a8">◆ </a></span>signal() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, T_arg1, T_arg2, T_arg3, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a706478aa21230e1b6ff4347f87efb0dc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a706478aa21230e1b6ff4347f87efb0dc">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, T_arg1, T_arg2, T_arg3, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a8a0166f439840b854ab3253fa831bb03"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8a0166f439840b854ab3253fa831bb03">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, T_arg3, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, T_arg1, T_arg2, T_arg3, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#aa686af4f961b098a23d4f7276437c2b0">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#ab89b1876c69ea40954b0af37e75a21b4">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#ad507bc5ea29adb2305f8fa91acbd30ee">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#aacb8fe57ffe01dea5c5fb5af44634287">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#ad2d5f3169ba147de8d43fde9e93bac98">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a01379d580d21de8bc8d0d2d62e6324ea">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a658ba1c6468882c9b1d480be2bbaf55e">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a844d15c61c83933575e7953b29365efa">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#ac8b73c0624273b8dae819255961ea6a3">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a3baee6b97500078ea6297959e1f9ca9c">operator=</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ab610351f5cdf9f332d9a1003a0481ab3">operator=</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#abeb05d9a2b40882bad753fccad6522be">signal2< T_return, T_arg1, T_arg2, nil >::operator=</a>(const signal2 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a5d3f71fb9ee8754c4640fb5bfb954151">signal2< T_return, T_arg1, T_arg2, nil >::operator=</a>(signal2 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a6710759bdeb8e626fc09d8c448e6613f">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a3ad9be2894fd3f78bfde9488207ff502">signal</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a199611dacb9e03614c9203ad27597667">signal</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ae7f76745ea92595cdd179725425487ea">signal</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a47aba9b19bc2bef0be7183022567e3ea">signal2</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#aa634515507f2ea4a35584e12e2dc92e7">signal2</a>(const signal2 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a20c59f06175d4c48394c65035d2c3376">signal2</a>(signal2 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#af31262f54dfb2a97540de9c4a1fc5726">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#ac28b0205aa1e60cc5ce062d4d8545323">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#aa6be4804147afd56657abf5b4cf8ce3d">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#nested-classes">Classes</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal2.html" title="Signal declaration.">sigc::signal2</a> template.
+ <a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4__inherit__graph.png" border="0" usemap="#asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map" id="asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::signal2 template." alt="" coords="9,244,177,300"/>
+<area shape="rect" href="classsigc_1_1signal2.html" title=" " alt="" coords="5,155,181,196"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="27,80,160,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="35,5,151,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Classes</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html">accumulated</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal2.html" title="Signal declaration.">sigc::signal2</a> template. <a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a3ad9be2894fd3f78bfde9488207ff502"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a3ad9be2894fd3f78bfde9488207ff502">signal</a> ()</td></tr>
+<tr class="separator:a3ad9be2894fd3f78bfde9488207ff502"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a199611dacb9e03614c9203ad27597667"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a199611dacb9e03614c9203ad27597667">signal</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:a199611dacb9e03614c9203ad27597667"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae7f76745ea92595cdd179725425487ea"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ae7f76745ea92595cdd179725425487ea">signal</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:ae7f76745ea92595cdd179725425487ea"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3baee6b97500078ea6297959e1f9ca9c"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a3baee6b97500078ea6297959e1f9ca9c">operator=</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:a3baee6b97500078ea6297959e1f9ca9c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab610351f5cdf9f332d9a1003a0481ab3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ab610351f5cdf9f332d9a1003a0481ab3">operator=</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:ab610351f5cdf9f332d9a1003a0481ab3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal2"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal2')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td></tr>
+<tr class="memitem:a47aba9b19bc2bef0be7183022567e3ea inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a47aba9b19bc2bef0be7183022567e3ea">signal2</a> ()</td></tr>
+<tr class="separator:a47aba9b19bc2bef0be7183022567e3ea inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa634515507f2ea4a35584e12e2dc92e7 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#aa634515507f2ea4a35584e12e2dc92e7">signal2</a> (const <a class="el" href="classsigc_1_1signal2.html">signal2</a> & src)</td></tr>
+<tr class="separator:aa634515507f2ea4a35584e12e2dc92e7 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a20c59f06175d4c48394c65035d2c3376 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a20c59f06175d4c48394c65035d2c3376">signal2</a> (<a class="el" href="classsigc_1_1signal2.html">signal2</a> && src)</td></tr>
+<tr class="separator:a20c59f06175d4c48394c65035d2c3376 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa686af4f961b098a23d4f7276437c2b0 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#a658ba1c6468882c9b1d480be2bbaf55e">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#aa686af4f961b098a23d4f7276437c2b0">connect</a> (const <a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:aa686af4f961b098a23d4f7276437c2b0 inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal2.html#aa686af4f961b098a23d4f7276437c2b0">More...</a><br /></td></tr>
+<tr class="separator:aa686af4f961b098a23d4f7276437c2b0 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab89b1876c69ea40954b0af37e75a21b4 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#a658ba1c6468882c9b1d480be2bbaf55e">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#ab89b1876c69ea40954b0af37e75a21b4">connect</a> (<a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:ab89b1876c69ea40954b0af37e75a21b4 inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal2.html#ab89b1876c69ea40954b0af37e75a21b4">More...</a><br /></td></tr>
+<tr class="separator:ab89b1876c69ea40954b0af37e75a21b4 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afd12e2a266a6399cc32e888d6f5e6f2f inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:afd12e2a266a6399cc32e888d6f5e6f2f inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f">More...</a><br /></td></tr>
+<tr class="separator:afd12e2a266a6399cc32e888d6f5e6f2f inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad2d5f3169ba147de8d43fde9e93bac98 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#ad2d5f3169ba147de8d43fde9e93bac98">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:ad2d5f3169ba147de8d43fde9e93bac98 inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal2.html#ad2d5f3169ba147de8d43fde9e93bac98">More...</a><br /></td></tr>
+<tr class="separator:ad2d5f3169ba147de8d43fde9e93bac98 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a844d15c61c83933575e7953b29365efa inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html">bound_const_mem_functor2</a>< <a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a>, <a class="el" href="classsigc_1_1signal2.html">signal2</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a844d15c61c83933575e7953b29365efa">make_slot</a> () const</td></tr>
+<tr class="memdesc:a844d15c61c83933575e7953b29365efa inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal2.html#a844d15c61c83933575e7953b29365efa">More...</a><br /></td></tr>
+<tr class="separator:a844d15c61c83933575e7953b29365efa inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8b73c0624273b8dae819255961ea6a3 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#ac8b73c0624273b8dae819255961ea6a3">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:ac8b73c0624273b8dae819255961ea6a3 inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal2.html#ac8b73c0624273b8dae819255961ea6a3">More...</a><br /></td></tr>
+<tr class="separator:ac8b73c0624273b8dae819255961ea6a3 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abeb05d9a2b40882bad753fccad6522be inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html">signal2</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#abeb05d9a2b40882bad753fccad6522be">operator=</a> (const <a class="el" href="classsigc_1_1signal2.html">signal2</a> & src)</td></tr>
+<tr class="separator:abeb05d9a2b40882bad753fccad6522be inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5d3f71fb9ee8754c4640fb5bfb954151 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html">signal2</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a5d3f71fb9ee8754c4640fb5bfb954151">operator=</a> (<a class="el" href="classsigc_1_1signal2.html">signal2</a> && src)</td></tr>
+<tr class="separator:a5d3f71fb9ee8754c4640fb5bfb954151 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac28b0205aa1e60cc5ce062d4d8545323 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#af31262f54dfb2a97540de9c4a1fc5726">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#ac28b0205aa1e60cc5ce062d4d8545323">slots</a> ()</td></tr>
+<tr class="memdesc:ac28b0205aa1e60cc5ce062d4d8545323 inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal2.html#ac28b0205aa1e60cc5ce062d4d8545323">More...</a><br /></td></tr>
+<tr class="separator:ac28b0205aa1e60cc5ce062d4d8545323 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa6be4804147afd56657abf5b4cf8ce3d inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal2.html#af31262f54dfb2a97540de9c4a1fc5726">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#aa6be4804147afd56657abf5b4cf8ce3d">slots</a> () const</td></tr>
+<tr class="memdesc:aa6be4804147afd56657abf5b4cf8ce3d inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal2.html#aa6be4804147afd56657abf5b4cf8ce3d">More...</a><br /></td></tr>
+<tr class="separator:aa6be4804147afd56657abf5b4cf8ce3d inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal2"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal2')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td></tr>
+<tr class="memitem:ad507bc5ea29adb2305f8fa91acbd30ee inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#ad507bc5ea29adb2305f8fa91acbd30ee">const_iterator</a></td></tr>
+<tr class="separator:ad507bc5ea29adb2305f8fa91acbd30ee inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aacb8fe57ffe01dea5c5fb5af44634287 inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#aacb8fe57ffe01dea5c5fb5af44634287">const_reverse_iterator</a></td></tr>
+<tr class="separator:aacb8fe57ffe01dea5c5fb5af44634287 inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a01379d580d21de8bc8d0d2d62e6324ea inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit2< T_return, T_arg1, T_arg2, <a class="el" href="structsigc_1_1nil.html">nil</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a01379d580d21de8bc8d0d2d62e6324ea">emitter_type</a></td></tr>
+<tr class="separator:a01379d580d21de8bc8d0d2d62e6324ea inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a658ba1c6468882c9b1d480be2bbaf55e inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a658ba1c6468882c9b1d480be2bbaf55e">iterator</a></td></tr>
+<tr class="separator:a658ba1c6468882c9b1d480be2bbaf55e inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a55151695417c33540357ff524bfe2665 inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a></td></tr>
+<tr class="separator:a55151695417c33540357ff524bfe2665 inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a6710759bdeb8e626fc09d8c448e6613f inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a6710759bdeb8e626fc09d8c448e6613f">reverse_iterator</a></td></tr>
+<tr class="separator:a6710759bdeb8e626fc09d8c448e6613f inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af31262f54dfb2a97540de9c4a1fc5726 inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#af31262f54dfb2a97540de9c4a1fc5726">slot_list_type</a></td></tr>
+<tr class="separator:af31262f54dfb2a97540de9c4a1fc5726 inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af7797ae10e76307f8d230588e760f119 inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a></td></tr>
+<tr class="separator:af7797ae10e76307f8d230588e760f119 inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2><br />
+class sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal2.html" title="Signal declaration.">sigc::signal2</a> template. </p>
+<p>See the base class for useful methods. This is the template specialization of the unnumbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> template for 2 argument(s).</p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000004">Deprecated:</a></b></dt><dd>Please use the syntax similar to that used by std::function<>: </dd></dl>
+<div class="fragment"><div class="line"><a class="code" href="classsigc_1_1slot.html">sigc::slot</a><void(<span class="keywordtype">bool</span>, <span class="keywordtype">int</span>)> some_slot;</div>
+<div class="ttc" id="aclasssigc_1_1slot_html"><div class="ttname"><a href="classsigc_1_1slot.html">sigc::slot</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::slot# templates.</div><div class="ttdef"><b>Definition:</b> slot.h:1645</div></div>
+</div><!-- fragment --> </div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a3ad9be2894fd3f78bfde9488207ff502"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3ad9be2894fd3f78bfde9488207ff502">◆ </a></span>signal() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a199611dacb9e03614c9203ad27597667"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a199611dacb9e03614c9203ad27597667">◆ </a></span>signal() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, T_arg1, T_arg2, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ae7f76745ea92595cdd179725425487ea"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae7f76745ea92595cdd179725425487ea">◆ </a></span>signal() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, T_arg1, T_arg2, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a3baee6b97500078ea6297959e1f9ca9c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3baee6b97500078ea6297959e1f9ca9c">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, T_arg1, T_arg2, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ab610351f5cdf9f332d9a1003a0481ab3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab610351f5cdf9f332d9a1003a0481ab3">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, T_arg1, T_arg2, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::accumulated< T_accumulator > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_2834c669b9a4f4ae3cbd91fd9ea54658.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::accumulated< T_accumulator > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal2.html" title="Signal declaration.">sigc::signal2</a> template.
+ <a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::accumulated< T_accumulator >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_dc4a103abb90b58689e91ed00e1a72ef.png" border="0" usemap="#asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" id="asigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::signal2 template." alt="" coords="10,244,242,315"/>
+<area shape="rect" href="classsigc_1_1signal2.html" title=" " alt="" coords="5,155,247,196"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="59,80,193,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="68,5,184,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a83f917545362d71b7d08fee23e619eaf"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#a83f917545362d71b7d08fee23e619eaf">accumulated</a> ()</td></tr>
+<tr class="separator:a83f917545362d71b7d08fee23e619eaf"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa462577f7f52f54b2bf2c87cbb7aa9bc"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#aa462577f7f52f54b2bf2c87cbb7aa9bc">accumulated</a> (const accumulated & src)</td></tr>
+<tr class="separator:aa462577f7f52f54b2bf2c87cbb7aa9bc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal2"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal2')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td></tr>
+<tr class="memitem:a47aba9b19bc2bef0be7183022567e3ea inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a47aba9b19bc2bef0be7183022567e3ea">signal2</a> ()</td></tr>
+<tr class="separator:a47aba9b19bc2bef0be7183022567e3ea inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa634515507f2ea4a35584e12e2dc92e7 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#aa634515507f2ea4a35584e12e2dc92e7">signal2</a> (const <a class="el" href="classsigc_1_1signal2.html">signal2</a> & src)</td></tr>
+<tr class="separator:aa634515507f2ea4a35584e12e2dc92e7 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a20c59f06175d4c48394c65035d2c3376 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a20c59f06175d4c48394c65035d2c3376">signal2</a> (<a class="el" href="classsigc_1_1signal2.html">signal2</a> && src)</td></tr>
+<tr class="separator:a20c59f06175d4c48394c65035d2c3376 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa686af4f961b098a23d4f7276437c2b0 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#a658ba1c6468882c9b1d480be2bbaf55e">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#aa686af4f961b098a23d4f7276437c2b0">connect</a> (const <a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:aa686af4f961b098a23d4f7276437c2b0 inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal2.html#aa686af4f961b098a23d4f7276437c2b0">More...</a><br /></td></tr>
+<tr class="separator:aa686af4f961b098a23d4f7276437c2b0 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab89b1876c69ea40954b0af37e75a21b4 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#a658ba1c6468882c9b1d480be2bbaf55e">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#ab89b1876c69ea40954b0af37e75a21b4">connect</a> (<a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:ab89b1876c69ea40954b0af37e75a21b4 inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal2.html#ab89b1876c69ea40954b0af37e75a21b4">More...</a><br /></td></tr>
+<tr class="separator:ab89b1876c69ea40954b0af37e75a21b4 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afd12e2a266a6399cc32e888d6f5e6f2f inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:afd12e2a266a6399cc32e888d6f5e6f2f inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f">More...</a><br /></td></tr>
+<tr class="separator:afd12e2a266a6399cc32e888d6f5e6f2f inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad2d5f3169ba147de8d43fde9e93bac98 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#ad2d5f3169ba147de8d43fde9e93bac98">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:ad2d5f3169ba147de8d43fde9e93bac98 inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal2.html#ad2d5f3169ba147de8d43fde9e93bac98">More...</a><br /></td></tr>
+<tr class="separator:ad2d5f3169ba147de8d43fde9e93bac98 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a844d15c61c83933575e7953b29365efa inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html">bound_const_mem_functor2</a>< <a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a>, <a class="el" href="classsigc_1_1signal2.html">signal2</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a844d15c61c83933575e7953b29365efa">make_slot</a> () const</td></tr>
+<tr class="memdesc:a844d15c61c83933575e7953b29365efa inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal2.html#a844d15c61c83933575e7953b29365efa">More...</a><br /></td></tr>
+<tr class="separator:a844d15c61c83933575e7953b29365efa inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8b73c0624273b8dae819255961ea6a3 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#ac8b73c0624273b8dae819255961ea6a3">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:ac8b73c0624273b8dae819255961ea6a3 inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal2.html#ac8b73c0624273b8dae819255961ea6a3">More...</a><br /></td></tr>
+<tr class="separator:ac8b73c0624273b8dae819255961ea6a3 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abeb05d9a2b40882bad753fccad6522be inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html">signal2</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#abeb05d9a2b40882bad753fccad6522be">operator=</a> (const <a class="el" href="classsigc_1_1signal2.html">signal2</a> & src)</td></tr>
+<tr class="separator:abeb05d9a2b40882bad753fccad6522be inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5d3f71fb9ee8754c4640fb5bfb954151 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html">signal2</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a5d3f71fb9ee8754c4640fb5bfb954151">operator=</a> (<a class="el" href="classsigc_1_1signal2.html">signal2</a> && src)</td></tr>
+<tr class="separator:a5d3f71fb9ee8754c4640fb5bfb954151 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac28b0205aa1e60cc5ce062d4d8545323 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#af31262f54dfb2a97540de9c4a1fc5726">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#ac28b0205aa1e60cc5ce062d4d8545323">slots</a> ()</td></tr>
+<tr class="memdesc:ac28b0205aa1e60cc5ce062d4d8545323 inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal2.html#ac28b0205aa1e60cc5ce062d4d8545323">More...</a><br /></td></tr>
+<tr class="separator:ac28b0205aa1e60cc5ce062d4d8545323 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa6be4804147afd56657abf5b4cf8ce3d inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal2.html#af31262f54dfb2a97540de9c4a1fc5726">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#aa6be4804147afd56657abf5b4cf8ce3d">slots</a> () const</td></tr>
+<tr class="memdesc:aa6be4804147afd56657abf5b4cf8ce3d inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal2.html#aa6be4804147afd56657abf5b4cf8ce3d">More...</a><br /></td></tr>
+<tr class="separator:aa6be4804147afd56657abf5b4cf8ce3d inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal2"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal2')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td></tr>
+<tr class="memitem:ad507bc5ea29adb2305f8fa91acbd30ee inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#ad507bc5ea29adb2305f8fa91acbd30ee">const_iterator</a></td></tr>
+<tr class="separator:ad507bc5ea29adb2305f8fa91acbd30ee inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aacb8fe57ffe01dea5c5fb5af44634287 inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#aacb8fe57ffe01dea5c5fb5af44634287">const_reverse_iterator</a></td></tr>
+<tr class="separator:aacb8fe57ffe01dea5c5fb5af44634287 inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a01379d580d21de8bc8d0d2d62e6324ea inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit2< T_return, T_arg1, T_arg2, T_accumulator > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a01379d580d21de8bc8d0d2d62e6324ea">emitter_type</a></td></tr>
+<tr class="separator:a01379d580d21de8bc8d0d2d62e6324ea inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a658ba1c6468882c9b1d480be2bbaf55e inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a658ba1c6468882c9b1d480be2bbaf55e">iterator</a></td></tr>
+<tr class="separator:a658ba1c6468882c9b1d480be2bbaf55e inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a55151695417c33540357ff524bfe2665 inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a></td></tr>
+<tr class="separator:a55151695417c33540357ff524bfe2665 inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a6710759bdeb8e626fc09d8c448e6613f inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a6710759bdeb8e626fc09d8c448e6613f">reverse_iterator</a></td></tr>
+<tr class="separator:a6710759bdeb8e626fc09d8c448e6613f inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af31262f54dfb2a97540de9c4a1fc5726 inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#af31262f54dfb2a97540de9c4a1fc5726">slot_list_type</a></td></tr>
+<tr class="separator:af31262f54dfb2a97540de9c4a1fc5726 inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af7797ae10e76307f8d230588e760f119 inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a></td></tr>
+<tr class="separator:af7797ae10e76307f8d230588e760f119 inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2><br />
+template <class T_accumulator><br />
+class sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::accumulated< T_accumulator ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal2.html" title="Signal declaration.">sigc::signal2</a> template. </p>
+<p>Like <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> but the additional template parameter <em>T_accumulator</em> defines the accumulator type that should be used. </p>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a83f917545362d71b7d08fee23e619eaf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a83f917545362d71b7d08fee23e619eaf">◆ </a></span>accumulated() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aa462577f7f52f54b2bf2c87cbb7aa9bc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa462577f7f52f54b2bf2c87cbb7aa9bc">◆ </a></span>accumulated() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, T_arg2, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramtype">const accumulated & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >" name="sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::signal2 template." alt="" coords="9,244,177,300"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal2.html" title=" " alt="" coords="5,155,181,196"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="27,80,160,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="35,5,151,32"/>
+</map>
--- /dev/null
+3760e68d6a9187c59811ac672f447116
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::accumulated< T_accumulator > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html">sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::accumulated< T_accumulator ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#a83f917545362d71b7d08fee23e619eaf">accumulated</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html">sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#aa462577f7f52f54b2bf2c87cbb7aa9bc">accumulated</a>(const accumulated & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html">sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#aa686af4f961b098a23d4f7276437c2b0">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#ab89b1876c69ea40954b0af37e75a21b4">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#ad507bc5ea29adb2305f8fa91acbd30ee">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#aacb8fe57ffe01dea5c5fb5af44634287">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#ad2d5f3169ba147de8d43fde9e93bac98">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a01379d580d21de8bc8d0d2d62e6324ea">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a658ba1c6468882c9b1d480be2bbaf55e">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a844d15c61c83933575e7953b29365efa">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#ac8b73c0624273b8dae819255961ea6a3">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#abeb05d9a2b40882bad753fccad6522be">operator=</a>(const signal2 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a5d3f71fb9ee8754c4640fb5bfb954151">operator=</a>(signal2 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a6710759bdeb8e626fc09d8c448e6613f">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a47aba9b19bc2bef0be7183022567e3ea">signal2</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#aa634515507f2ea4a35584e12e2dc92e7">signal2</a>(const signal2 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a20c59f06175d4c48394c65035d2c3376">signal2</a>(signal2 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#af31262f54dfb2a97540de9c4a1fc5726">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#ac28b0205aa1e60cc5ce062d4d8545323">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#aa6be4804147afd56657abf5b4cf8ce3d">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::accumulated< T_accumulator >" name="sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::accumulated< T_accumulator >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::signal2 template." alt="" coords="10,244,242,315"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal2.html" title=" " alt="" coords="5,155,247,196"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="59,80,193,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="68,5,184,32"/>
+</map>
--- /dev/null
+ef78d324bbc4f44f661fcd714ee186f7
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#aac2ade0896bd4a982777d5dd6ac75888">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#ac69d2681c586b310d8c056a319bb65fe">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#af1e262b35c9574e65b2607cdfcaad707">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#aeb327519f808dfec9a723511ef82caa3">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42">emit</a>(type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a449fc940ae822c4b6ea9282b9b292015">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a63c6e2b55c8c3af083402bb7f5a66593">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#ab61e2d1fcaf903dffbb26b01800907fb">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a87513117263fd39d5a5a86e0fb8b2a78">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a828907c11f5c18d9522e5d5139484620">operator()</a>(type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a418026bd364a6b5510f0227f497b9473">operator=</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ac10afd98d20258707f8748f4af3063d9">operator=</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a29cd06bf91f96f11c5f29237b8afbb71">signal1< T_return, T_arg1, nil >::operator=</a>(const signal1 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#ab817711d4bc93402d15e87b89a09c364">signal1< T_return, T_arg1, nil >::operator=</a>(signal1 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#ab0443049aa736d88770d0f534600b2bc">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a7561df6caf1f508eff71f035db8260c1">signal</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ae55caf393287987076a093a17cd2a272">signal</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#aee2249d4e36771d4f2d5f6c8848a95ce">signal</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#aba62d8d0b9591bcfd728f8ae8a22d600">signal1</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#ab3378dd754ffddb4760f2a3afb271dbe">signal1</a>(const signal1 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a85ec968e0b25ee9285f297da5416b2a4">signal1</a>(signal1 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a5fadeb350140d6aaf560b217e7e7c4b4">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a7653b68e6a3b8445de91f89060bf2600">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a7777660b21fef2a6941c7dff23964604">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#nested-classes">Classes</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal1.html" title="Signal declaration.">sigc::signal1</a> template.
+ <a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4__inherit__graph.png" border="0" usemap="#asigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map" id="asigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::signal1 template." alt="" coords="9,244,177,300"/>
+<area shape="rect" href="classsigc_1_1signal1.html" title=" " alt="" coords="5,155,181,196"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="27,80,160,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="35,5,151,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Classes</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html">accumulated</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal1.html" title="Signal declaration.">sigc::signal1</a> template. <a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a7561df6caf1f508eff71f035db8260c1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a7561df6caf1f508eff71f035db8260c1">signal</a> ()</td></tr>
+<tr class="separator:a7561df6caf1f508eff71f035db8260c1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae55caf393287987076a093a17cd2a272"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ae55caf393287987076a093a17cd2a272">signal</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:ae55caf393287987076a093a17cd2a272"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aee2249d4e36771d4f2d5f6c8848a95ce"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#aee2249d4e36771d4f2d5f6c8848a95ce">signal</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:aee2249d4e36771d4f2d5f6c8848a95ce"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a418026bd364a6b5510f0227f497b9473"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a418026bd364a6b5510f0227f497b9473">operator=</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:a418026bd364a6b5510f0227f497b9473"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac10afd98d20258707f8748f4af3063d9"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ac10afd98d20258707f8748f4af3063d9">operator=</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:ac10afd98d20258707f8748f4af3063d9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal1"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal1')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td></tr>
+<tr class="memitem:aba62d8d0b9591bcfd728f8ae8a22d600 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#aba62d8d0b9591bcfd728f8ae8a22d600">signal1</a> ()</td></tr>
+<tr class="separator:aba62d8d0b9591bcfd728f8ae8a22d600 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab3378dd754ffddb4760f2a3afb271dbe inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#ab3378dd754ffddb4760f2a3afb271dbe">signal1</a> (const <a class="el" href="classsigc_1_1signal1.html">signal1</a> & src)</td></tr>
+<tr class="separator:ab3378dd754ffddb4760f2a3afb271dbe inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a85ec968e0b25ee9285f297da5416b2a4 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a85ec968e0b25ee9285f297da5416b2a4">signal1</a> (<a class="el" href="classsigc_1_1signal1.html">signal1</a> && src)</td></tr>
+<tr class="separator:a85ec968e0b25ee9285f297da5416b2a4 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aac2ade0896bd4a982777d5dd6ac75888 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#ab61e2d1fcaf903dffbb26b01800907fb">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#aac2ade0896bd4a982777d5dd6ac75888">connect</a> (const <a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:aac2ade0896bd4a982777d5dd6ac75888 inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal1.html#aac2ade0896bd4a982777d5dd6ac75888">More...</a><br /></td></tr>
+<tr class="separator:aac2ade0896bd4a982777d5dd6ac75888 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac69d2681c586b310d8c056a319bb65fe inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#ab61e2d1fcaf903dffbb26b01800907fb">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#ac69d2681c586b310d8c056a319bb65fe">connect</a> (<a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:ac69d2681c586b310d8c056a319bb65fe inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal1.html#ac69d2681c586b310d8c056a319bb65fe">More...</a><br /></td></tr>
+<tr class="separator:ac69d2681c586b310d8c056a319bb65fe inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:affe595f8b70b4f43a21be7192c0cba42 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:affe595f8b70b4f43a21be7192c0cba42 inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42">More...</a><br /></td></tr>
+<tr class="separator:affe595f8b70b4f43a21be7192c0cba42 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a449fc940ae822c4b6ea9282b9b292015 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a449fc940ae822c4b6ea9282b9b292015">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a449fc940ae822c4b6ea9282b9b292015 inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal1.html#a449fc940ae822c4b6ea9282b9b292015">More...</a><br /></td></tr>
+<tr class="separator:a449fc940ae822c4b6ea9282b9b292015 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87513117263fd39d5a5a86e0fb8b2a78 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html">bound_const_mem_functor1</a>< <a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a>, <a class="el" href="classsigc_1_1signal1.html">signal1</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a87513117263fd39d5a5a86e0fb8b2a78">make_slot</a> () const</td></tr>
+<tr class="memdesc:a87513117263fd39d5a5a86e0fb8b2a78 inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal1.html#a87513117263fd39d5a5a86e0fb8b2a78">More...</a><br /></td></tr>
+<tr class="separator:a87513117263fd39d5a5a86e0fb8b2a78 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a828907c11f5c18d9522e5d5139484620 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a828907c11f5c18d9522e5d5139484620">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a828907c11f5c18d9522e5d5139484620 inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal1.html#a828907c11f5c18d9522e5d5139484620">More...</a><br /></td></tr>
+<tr class="separator:a828907c11f5c18d9522e5d5139484620 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a29cd06bf91f96f11c5f29237b8afbb71 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html">signal1</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a29cd06bf91f96f11c5f29237b8afbb71">operator=</a> (const <a class="el" href="classsigc_1_1signal1.html">signal1</a> & src)</td></tr>
+<tr class="separator:a29cd06bf91f96f11c5f29237b8afbb71 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab817711d4bc93402d15e87b89a09c364 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html">signal1</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#ab817711d4bc93402d15e87b89a09c364">operator=</a> (<a class="el" href="classsigc_1_1signal1.html">signal1</a> && src)</td></tr>
+<tr class="separator:ab817711d4bc93402d15e87b89a09c364 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7653b68e6a3b8445de91f89060bf2600 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#a5fadeb350140d6aaf560b217e7e7c4b4">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a7653b68e6a3b8445de91f89060bf2600">slots</a> ()</td></tr>
+<tr class="memdesc:a7653b68e6a3b8445de91f89060bf2600 inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal1.html#a7653b68e6a3b8445de91f89060bf2600">More...</a><br /></td></tr>
+<tr class="separator:a7653b68e6a3b8445de91f89060bf2600 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7777660b21fef2a6941c7dff23964604 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal1.html#a5fadeb350140d6aaf560b217e7e7c4b4">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a7777660b21fef2a6941c7dff23964604">slots</a> () const</td></tr>
+<tr class="memdesc:a7777660b21fef2a6941c7dff23964604 inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal1.html#a7777660b21fef2a6941c7dff23964604">More...</a><br /></td></tr>
+<tr class="separator:a7777660b21fef2a6941c7dff23964604 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal1"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal1')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td></tr>
+<tr class="memitem:af1e262b35c9574e65b2607cdfcaad707 inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#af1e262b35c9574e65b2607cdfcaad707">const_iterator</a></td></tr>
+<tr class="separator:af1e262b35c9574e65b2607cdfcaad707 inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aeb327519f808dfec9a723511ef82caa3 inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#aeb327519f808dfec9a723511ef82caa3">const_reverse_iterator</a></td></tr>
+<tr class="separator:aeb327519f808dfec9a723511ef82caa3 inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a63c6e2b55c8c3af083402bb7f5a66593 inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit1< T_return, T_arg1, <a class="el" href="structsigc_1_1nil.html">nil</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a63c6e2b55c8c3af083402bb7f5a66593">emitter_type</a></td></tr>
+<tr class="separator:a63c6e2b55c8c3af083402bb7f5a66593 inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab61e2d1fcaf903dffbb26b01800907fb inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#ab61e2d1fcaf903dffbb26b01800907fb">iterator</a></td></tr>
+<tr class="separator:ab61e2d1fcaf903dffbb26b01800907fb inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adcdcfa50d60e1832ce038a4a5554fce1 inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a></td></tr>
+<tr class="separator:adcdcfa50d60e1832ce038a4a5554fce1 inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0443049aa736d88770d0f534600b2bc inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#ab0443049aa736d88770d0f534600b2bc">reverse_iterator</a></td></tr>
+<tr class="separator:ab0443049aa736d88770d0f534600b2bc inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5fadeb350140d6aaf560b217e7e7c4b4 inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a5fadeb350140d6aaf560b217e7e7c4b4">slot_list_type</a></td></tr>
+<tr class="separator:a5fadeb350140d6aaf560b217e7e7c4b4 inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a310736e1415c2cf4578892ffff35915c inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a></td></tr>
+<tr class="separator:a310736e1415c2cf4578892ffff35915c inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1><br />
+class sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal1.html" title="Signal declaration.">sigc::signal1</a> template. </p>
+<p>See the base class for useful methods. This is the template specialization of the unnumbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> template for 1 argument(s).</p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000003">Deprecated:</a></b></dt><dd>Please use the syntax similar to that used by std::function<>: </dd></dl>
+<div class="fragment"><div class="line"><a class="code" href="classsigc_1_1slot.html">sigc::slot</a><void(<span class="keywordtype">bool</span>, <span class="keywordtype">int</span>)> some_slot;</div>
+<div class="ttc" id="aclasssigc_1_1slot_html"><div class="ttname"><a href="classsigc_1_1slot.html">sigc::slot</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::slot# templates.</div><div class="ttdef"><b>Definition:</b> slot.h:1645</div></div>
+</div><!-- fragment --> </div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a7561df6caf1f508eff71f035db8260c1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7561df6caf1f508eff71f035db8260c1">◆ </a></span>signal() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ae55caf393287987076a093a17cd2a272"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae55caf393287987076a093a17cd2a272">◆ </a></span>signal() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, T_arg1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aee2249d4e36771d4f2d5f6c8848a95ce"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aee2249d4e36771d4f2d5f6c8848a95ce">◆ </a></span>signal() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, T_arg1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a418026bd364a6b5510f0227f497b9473"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a418026bd364a6b5510f0227f497b9473">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, T_arg1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ac10afd98d20258707f8748f4af3063d9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac10afd98d20258707f8748f4af3063d9">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, T_arg1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::accumulated< T_accumulator > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_08a1617e39a89dfb3d657c3c5cb6673b1.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::accumulated< T_accumulator > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal1.html" title="Signal declaration.">sigc::signal1</a> template.
+ <a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::accumulated< T_accumulator >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_093dc18e43ee4275c7bebd699f7376cb7.png" border="0" usemap="#asigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" id="asigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::signal1 template." alt="" coords="5,244,203,315"/>
+<area shape="rect" href="classsigc_1_1signal1.html" title=" " alt="" coords="9,155,199,196"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="37,80,171,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="46,5,162,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a772b7939dc0552087c6b52a98d97eab8"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#a772b7939dc0552087c6b52a98d97eab8">accumulated</a> ()</td></tr>
+<tr class="separator:a772b7939dc0552087c6b52a98d97eab8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a94b30a9ffefefc43cb79b4f30ad65237"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#a94b30a9ffefefc43cb79b4f30ad65237">accumulated</a> (const accumulated & src)</td></tr>
+<tr class="separator:a94b30a9ffefefc43cb79b4f30ad65237"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal1"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal1')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td></tr>
+<tr class="memitem:aba62d8d0b9591bcfd728f8ae8a22d600 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#aba62d8d0b9591bcfd728f8ae8a22d600">signal1</a> ()</td></tr>
+<tr class="separator:aba62d8d0b9591bcfd728f8ae8a22d600 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab3378dd754ffddb4760f2a3afb271dbe inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#ab3378dd754ffddb4760f2a3afb271dbe">signal1</a> (const <a class="el" href="classsigc_1_1signal1.html">signal1</a> & src)</td></tr>
+<tr class="separator:ab3378dd754ffddb4760f2a3afb271dbe inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a85ec968e0b25ee9285f297da5416b2a4 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a85ec968e0b25ee9285f297da5416b2a4">signal1</a> (<a class="el" href="classsigc_1_1signal1.html">signal1</a> && src)</td></tr>
+<tr class="separator:a85ec968e0b25ee9285f297da5416b2a4 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aac2ade0896bd4a982777d5dd6ac75888 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#ab61e2d1fcaf903dffbb26b01800907fb">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#aac2ade0896bd4a982777d5dd6ac75888">connect</a> (const <a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:aac2ade0896bd4a982777d5dd6ac75888 inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal1.html#aac2ade0896bd4a982777d5dd6ac75888">More...</a><br /></td></tr>
+<tr class="separator:aac2ade0896bd4a982777d5dd6ac75888 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac69d2681c586b310d8c056a319bb65fe inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#ab61e2d1fcaf903dffbb26b01800907fb">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#ac69d2681c586b310d8c056a319bb65fe">connect</a> (<a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:ac69d2681c586b310d8c056a319bb65fe inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal1.html#ac69d2681c586b310d8c056a319bb65fe">More...</a><br /></td></tr>
+<tr class="separator:ac69d2681c586b310d8c056a319bb65fe inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:affe595f8b70b4f43a21be7192c0cba42 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:affe595f8b70b4f43a21be7192c0cba42 inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42">More...</a><br /></td></tr>
+<tr class="separator:affe595f8b70b4f43a21be7192c0cba42 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a449fc940ae822c4b6ea9282b9b292015 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a449fc940ae822c4b6ea9282b9b292015">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a449fc940ae822c4b6ea9282b9b292015 inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal1.html#a449fc940ae822c4b6ea9282b9b292015">More...</a><br /></td></tr>
+<tr class="separator:a449fc940ae822c4b6ea9282b9b292015 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87513117263fd39d5a5a86e0fb8b2a78 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html">bound_const_mem_functor1</a>< <a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a>, <a class="el" href="classsigc_1_1signal1.html">signal1</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a87513117263fd39d5a5a86e0fb8b2a78">make_slot</a> () const</td></tr>
+<tr class="memdesc:a87513117263fd39d5a5a86e0fb8b2a78 inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal1.html#a87513117263fd39d5a5a86e0fb8b2a78">More...</a><br /></td></tr>
+<tr class="separator:a87513117263fd39d5a5a86e0fb8b2a78 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a828907c11f5c18d9522e5d5139484620 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a828907c11f5c18d9522e5d5139484620">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a828907c11f5c18d9522e5d5139484620 inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal1.html#a828907c11f5c18d9522e5d5139484620">More...</a><br /></td></tr>
+<tr class="separator:a828907c11f5c18d9522e5d5139484620 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a29cd06bf91f96f11c5f29237b8afbb71 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html">signal1</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a29cd06bf91f96f11c5f29237b8afbb71">operator=</a> (const <a class="el" href="classsigc_1_1signal1.html">signal1</a> & src)</td></tr>
+<tr class="separator:a29cd06bf91f96f11c5f29237b8afbb71 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab817711d4bc93402d15e87b89a09c364 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html">signal1</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#ab817711d4bc93402d15e87b89a09c364">operator=</a> (<a class="el" href="classsigc_1_1signal1.html">signal1</a> && src)</td></tr>
+<tr class="separator:ab817711d4bc93402d15e87b89a09c364 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7653b68e6a3b8445de91f89060bf2600 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#a5fadeb350140d6aaf560b217e7e7c4b4">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a7653b68e6a3b8445de91f89060bf2600">slots</a> ()</td></tr>
+<tr class="memdesc:a7653b68e6a3b8445de91f89060bf2600 inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal1.html#a7653b68e6a3b8445de91f89060bf2600">More...</a><br /></td></tr>
+<tr class="separator:a7653b68e6a3b8445de91f89060bf2600 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7777660b21fef2a6941c7dff23964604 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal1.html#a5fadeb350140d6aaf560b217e7e7c4b4">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a7777660b21fef2a6941c7dff23964604">slots</a> () const</td></tr>
+<tr class="memdesc:a7777660b21fef2a6941c7dff23964604 inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal1.html#a7777660b21fef2a6941c7dff23964604">More...</a><br /></td></tr>
+<tr class="separator:a7777660b21fef2a6941c7dff23964604 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal1"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal1')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td></tr>
+<tr class="memitem:af1e262b35c9574e65b2607cdfcaad707 inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#af1e262b35c9574e65b2607cdfcaad707">const_iterator</a></td></tr>
+<tr class="separator:af1e262b35c9574e65b2607cdfcaad707 inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aeb327519f808dfec9a723511ef82caa3 inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#aeb327519f808dfec9a723511ef82caa3">const_reverse_iterator</a></td></tr>
+<tr class="separator:aeb327519f808dfec9a723511ef82caa3 inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a63c6e2b55c8c3af083402bb7f5a66593 inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit1< T_return, T_arg1, T_accumulator > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a63c6e2b55c8c3af083402bb7f5a66593">emitter_type</a></td></tr>
+<tr class="separator:a63c6e2b55c8c3af083402bb7f5a66593 inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab61e2d1fcaf903dffbb26b01800907fb inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#ab61e2d1fcaf903dffbb26b01800907fb">iterator</a></td></tr>
+<tr class="separator:ab61e2d1fcaf903dffbb26b01800907fb inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adcdcfa50d60e1832ce038a4a5554fce1 inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a></td></tr>
+<tr class="separator:adcdcfa50d60e1832ce038a4a5554fce1 inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0443049aa736d88770d0f534600b2bc inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#ab0443049aa736d88770d0f534600b2bc">reverse_iterator</a></td></tr>
+<tr class="separator:ab0443049aa736d88770d0f534600b2bc inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5fadeb350140d6aaf560b217e7e7c4b4 inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a5fadeb350140d6aaf560b217e7e7c4b4">slot_list_type</a></td></tr>
+<tr class="separator:a5fadeb350140d6aaf560b217e7e7c4b4 inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a310736e1415c2cf4578892ffff35915c inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a></td></tr>
+<tr class="separator:a310736e1415c2cf4578892ffff35915c inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1><br />
+template <class T_accumulator><br />
+class sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::accumulated< T_accumulator ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal1.html" title="Signal declaration.">sigc::signal1</a> template. </p>
+<p>Like <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> but the additional template parameter <em>T_accumulator</em> defines the accumulator type that should be used. </p>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a772b7939dc0552087c6b52a98d97eab8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a772b7939dc0552087c6b52a98d97eab8">◆ </a></span>accumulated() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a94b30a9ffefefc43cb79b4f30ad65237"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a94b30a9ffefefc43cb79b4f30ad65237">◆ </a></span>accumulated() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, T_arg1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramtype">const accumulated & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >" name="sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::signal1 template." alt="" coords="9,244,177,300"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal1.html" title=" " alt="" coords="5,155,181,196"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="27,80,160,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="35,5,151,32"/>
+</map>
--- /dev/null
+403bbd5d317924c5b86fa31f5f39fbe0
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::accumulated< T_accumulator > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html">sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::accumulated< T_accumulator ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#a772b7939dc0552087c6b52a98d97eab8">accumulated</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html">sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#a94b30a9ffefefc43cb79b4f30ad65237">accumulated</a>(const accumulated & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html">sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#aac2ade0896bd4a982777d5dd6ac75888">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#ac69d2681c586b310d8c056a319bb65fe">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#af1e262b35c9574e65b2607cdfcaad707">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#aeb327519f808dfec9a723511ef82caa3">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42">emit</a>(type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a449fc940ae822c4b6ea9282b9b292015">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a63c6e2b55c8c3af083402bb7f5a66593">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#ab61e2d1fcaf903dffbb26b01800907fb">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a87513117263fd39d5a5a86e0fb8b2a78">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a828907c11f5c18d9522e5d5139484620">operator()</a>(type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a29cd06bf91f96f11c5f29237b8afbb71">operator=</a>(const signal1 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#ab817711d4bc93402d15e87b89a09c364">operator=</a>(signal1 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#ab0443049aa736d88770d0f534600b2bc">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#aba62d8d0b9591bcfd728f8ae8a22d600">signal1</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#ab3378dd754ffddb4760f2a3afb271dbe">signal1</a>(const signal1 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a85ec968e0b25ee9285f297da5416b2a4">signal1</a>(signal1 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a5fadeb350140d6aaf560b217e7e7c4b4">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a7653b68e6a3b8445de91f89060bf2600">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a7777660b21fef2a6941c7dff23964604">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::accumulated< T_accumulator >" name="sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::accumulated< T_accumulator >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::signal1 template." alt="" coords="5,244,203,315"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal1.html" title=" " alt="" coords="9,155,199,196"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="37,80,171,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="46,5,162,32"/>
+</map>
--- /dev/null
+42d66f18a9a11dcb4da2ea74e19189c7
\ No newline at end of file
--- /dev/null
+<map id="sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil >::accumulated< T_accumulator >" name="sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil >::accumulated< T_accumulator >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::signal0 template." alt="" coords="7,244,180,315"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal0.html" title=" " alt="" coords="5,155,181,196"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="27,80,160,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="35,5,151,32"/>
+</map>
--- /dev/null
+a5ee31ef89b18150023dc762cdefafd3
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, nil, nil, nil, nil, nil, nil, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a609b1e0770f47c9081a3de56b65314d2">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a9b78954271b6dba5e926bd960f3e7905">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ad4f7c62954f5c270e115d9b2a2df15ea">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a476f559a69eef5999c99cd6262a9aa2f">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8">emit</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#abdae39f9a7abd6133c03d65224c227d6">emit_reverse</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ac7eafdced2d325d6003327b4360bc2dd">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ad61e875748cf4e1c2a6d89a930ae093e">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a3295536428e5e0d6478ac10e2daff736">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a2dd3042c0681542ed6f2de5840f713a1">operator()</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a9603080b1a0c76e32eb6859594c59665">operator=</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a08ac3766c65bb61177b49a62667a5a53">operator=</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a4e8311eac2fd7f8ecd10bff8225ed9e3">signal0< T_return, nil >::operator=</a>(const signal0 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a693aa3743236012416349bfac56d31b6">signal0< T_return, nil >::operator=</a>(signal0 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a1d9c390974304392ed12ee81543ab997">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a69bd320a61ade13046ae3ed20498ab83">signal</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a3dcbc7a6481f46f08a366e489876a7a0">signal</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a59107d243fe3408d64e4e963d5023dcb">signal</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a2fb24e11a8f645e5122646ea2b4a5d2f">signal0</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a7dc687f1afb4088a3d888aa05dbf56d9">signal0</a>(const signal0 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ac1b915a86d0b75fd4e90c2a92f7ebc49">signal0</a>(signal0 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#add195c1c738ee8efe10294f21d258b77">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a5576113ddfd6b92a96f86072262307f9">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a73523d71edd7fb4294324e9561db6f3c">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, nil, nil, nil, nil, nil, nil, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#nested-classes">Classes</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal0.html" title="Signal declaration.">sigc::signal0</a> template.
+ <a href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4__inherit__graph.png" border="0" usemap="#asigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map" id="asigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::signal0 template." alt="" coords="9,244,177,300"/>
+<area shape="rect" href="classsigc_1_1signal0.html" title=" " alt="" coords="5,155,181,196"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="27,80,160,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="35,5,151,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Classes</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html">accumulated</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal0.html" title="Signal declaration.">sigc::signal0</a> template. <a href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a69bd320a61ade13046ae3ed20498ab83"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a69bd320a61ade13046ae3ed20498ab83">signal</a> ()</td></tr>
+<tr class="separator:a69bd320a61ade13046ae3ed20498ab83"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3dcbc7a6481f46f08a366e489876a7a0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a3dcbc7a6481f46f08a366e489876a7a0">signal</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:a3dcbc7a6481f46f08a366e489876a7a0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a59107d243fe3408d64e4e963d5023dcb"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a59107d243fe3408d64e4e963d5023dcb">signal</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:a59107d243fe3408d64e4e963d5023dcb"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9603080b1a0c76e32eb6859594c59665"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a9603080b1a0c76e32eb6859594c59665">operator=</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:a9603080b1a0c76e32eb6859594c59665"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a08ac3766c65bb61177b49a62667a5a53"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a08ac3766c65bb61177b49a62667a5a53">operator=</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:a08ac3766c65bb61177b49a62667a5a53"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal0"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal0')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td></tr>
+<tr class="memitem:a2fb24e11a8f645e5122646ea2b4a5d2f inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a2fb24e11a8f645e5122646ea2b4a5d2f">signal0</a> ()</td></tr>
+<tr class="separator:a2fb24e11a8f645e5122646ea2b4a5d2f inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7dc687f1afb4088a3d888aa05dbf56d9 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a7dc687f1afb4088a3d888aa05dbf56d9">signal0</a> (const <a class="el" href="classsigc_1_1signal0.html">signal0</a> & src)</td></tr>
+<tr class="separator:a7dc687f1afb4088a3d888aa05dbf56d9 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac1b915a86d0b75fd4e90c2a92f7ebc49 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ac1b915a86d0b75fd4e90c2a92f7ebc49">signal0</a> (<a class="el" href="classsigc_1_1signal0.html">signal0</a> && src)</td></tr>
+<tr class="separator:ac1b915a86d0b75fd4e90c2a92f7ebc49 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a609b1e0770f47c9081a3de56b65314d2 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#ad61e875748cf4e1c2a6d89a930ae093e">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a609b1e0770f47c9081a3de56b65314d2">connect</a> (const <a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:a609b1e0770f47c9081a3de56b65314d2 inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal0.html#a609b1e0770f47c9081a3de56b65314d2">More...</a><br /></td></tr>
+<tr class="separator:a609b1e0770f47c9081a3de56b65314d2 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9b78954271b6dba5e926bd960f3e7905 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#ad61e875748cf4e1c2a6d89a930ae093e">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a9b78954271b6dba5e926bd960f3e7905">connect</a> (<a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:a9b78954271b6dba5e926bd960f3e7905 inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal0.html#a9b78954271b6dba5e926bd960f3e7905">More...</a><br /></td></tr>
+<tr class="separator:a9b78954271b6dba5e926bd960f3e7905 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a655829125186645bcbc61db8252134a8 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8">emit</a> () const</td></tr>
+<tr class="memdesc:a655829125186645bcbc61db8252134a8 inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8">More...</a><br /></td></tr>
+<tr class="separator:a655829125186645bcbc61db8252134a8 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abdae39f9a7abd6133c03d65224c227d6 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#abdae39f9a7abd6133c03d65224c227d6">emit_reverse</a> () const</td></tr>
+<tr class="memdesc:abdae39f9a7abd6133c03d65224c227d6 inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal0.html#abdae39f9a7abd6133c03d65224c227d6">More...</a><br /></td></tr>
+<tr class="separator:abdae39f9a7abd6133c03d65224c227d6 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3295536428e5e0d6478ac10e2daff736 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html">bound_const_mem_functor0</a>< <a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a>, <a class="el" href="classsigc_1_1signal0.html">signal0</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a3295536428e5e0d6478ac10e2daff736">make_slot</a> () const</td></tr>
+<tr class="memdesc:a3295536428e5e0d6478ac10e2daff736 inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal0.html#a3295536428e5e0d6478ac10e2daff736">More...</a><br /></td></tr>
+<tr class="separator:a3295536428e5e0d6478ac10e2daff736 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2dd3042c0681542ed6f2de5840f713a1 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a2dd3042c0681542ed6f2de5840f713a1">operator()</a> () const</td></tr>
+<tr class="memdesc:a2dd3042c0681542ed6f2de5840f713a1 inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal0.html#a2dd3042c0681542ed6f2de5840f713a1">More...</a><br /></td></tr>
+<tr class="separator:a2dd3042c0681542ed6f2de5840f713a1 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4e8311eac2fd7f8ecd10bff8225ed9e3 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html">signal0</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a4e8311eac2fd7f8ecd10bff8225ed9e3">operator=</a> (const <a class="el" href="classsigc_1_1signal0.html">signal0</a> & src)</td></tr>
+<tr class="separator:a4e8311eac2fd7f8ecd10bff8225ed9e3 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a693aa3743236012416349bfac56d31b6 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html">signal0</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a693aa3743236012416349bfac56d31b6">operator=</a> (<a class="el" href="classsigc_1_1signal0.html">signal0</a> && src)</td></tr>
+<tr class="separator:a693aa3743236012416349bfac56d31b6 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5576113ddfd6b92a96f86072262307f9 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#add195c1c738ee8efe10294f21d258b77">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a5576113ddfd6b92a96f86072262307f9">slots</a> ()</td></tr>
+<tr class="memdesc:a5576113ddfd6b92a96f86072262307f9 inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal0.html#a5576113ddfd6b92a96f86072262307f9">More...</a><br /></td></tr>
+<tr class="separator:a5576113ddfd6b92a96f86072262307f9 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a73523d71edd7fb4294324e9561db6f3c inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal0.html#add195c1c738ee8efe10294f21d258b77">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a73523d71edd7fb4294324e9561db6f3c">slots</a> () const</td></tr>
+<tr class="memdesc:a73523d71edd7fb4294324e9561db6f3c inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal0.html#a73523d71edd7fb4294324e9561db6f3c">More...</a><br /></td></tr>
+<tr class="separator:a73523d71edd7fb4294324e9561db6f3c inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal0"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal0')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td></tr>
+<tr class="memitem:ad4f7c62954f5c270e115d9b2a2df15ea inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ad4f7c62954f5c270e115d9b2a2df15ea">const_iterator</a></td></tr>
+<tr class="separator:ad4f7c62954f5c270e115d9b2a2df15ea inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a476f559a69eef5999c99cd6262a9aa2f inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a476f559a69eef5999c99cd6262a9aa2f">const_reverse_iterator</a></td></tr>
+<tr class="separator:a476f559a69eef5999c99cd6262a9aa2f inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac7eafdced2d325d6003327b4360bc2dd inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit0< T_return, <a class="el" href="structsigc_1_1nil.html">nil</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ac7eafdced2d325d6003327b4360bc2dd">emitter_type</a></td></tr>
+<tr class="separator:ac7eafdced2d325d6003327b4360bc2dd inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad61e875748cf4e1c2a6d89a930ae093e inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ad61e875748cf4e1c2a6d89a930ae093e">iterator</a></td></tr>
+<tr class="separator:ad61e875748cf4e1c2a6d89a930ae093e inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae291a90c83f8ad1cdcc7c2a4cdd958de inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a></td></tr>
+<tr class="separator:ae291a90c83f8ad1cdcc7c2a4cdd958de inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1d9c390974304392ed12ee81543ab997 inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a1d9c390974304392ed12ee81543ab997">reverse_iterator</a></td></tr>
+<tr class="separator:a1d9c390974304392ed12ee81543ab997 inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:add195c1c738ee8efe10294f21d258b77 inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#add195c1c738ee8efe10294f21d258b77">slot_list_type</a></td></tr>
+<tr class="separator:add195c1c738ee8efe10294f21d258b77 inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae3fc90cec344b6585979e77d2b359287 inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return()> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a></td></tr>
+<tr class="separator:ae3fc90cec344b6585979e77d2b359287 inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return><br />
+class sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal0.html" title="Signal declaration.">sigc::signal0</a> template. </p>
+<p>See the base class for useful methods. This is the template specialization of the unnumbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> template for 0 argument(s).</p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000002">Deprecated:</a></b></dt><dd>Please use the syntax similar to that used by std::function<>: </dd></dl>
+<div class="fragment"><div class="line"><a class="code" href="classsigc_1_1slot.html">sigc::slot</a><void(<span class="keywordtype">bool</span>, <span class="keywordtype">int</span>)> some_slot;</div>
+<div class="ttc" id="aclasssigc_1_1slot_html"><div class="ttname"><a href="classsigc_1_1slot.html">sigc::slot</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::slot# templates.</div><div class="ttdef"><b>Definition:</b> slot.h:1645</div></div>
+</div><!-- fragment --> </div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a69bd320a61ade13046ae3ed20498ab83"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a69bd320a61ade13046ae3ed20498ab83">◆ </a></span>signal() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a3dcbc7a6481f46f08a366e489876a7a0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3dcbc7a6481f46f08a366e489876a7a0">◆ </a></span>signal() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a59107d243fe3408d64e4e963d5023dcb"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a59107d243fe3408d64e4e963d5023dcb">◆ </a></span>signal() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a9603080b1a0c76e32eb6859594c59665"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9603080b1a0c76e32eb6859594c59665">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a08ac3766c65bb61177b49a62667a5a53"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a08ac3766c65bb61177b49a62667a5a53">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, nil, nil, nil, nil, nil, nil, nil ></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil >::accumulated< T_accumulator > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html">sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil >::accumulated< T_accumulator ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#a54763bd7352a9c84b5e5956b4f65c914">accumulated</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html">sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil >::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#a1cea5890a6ac54f475ae28062c99e4f4">accumulated</a>(const accumulated & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html">sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil >::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a609b1e0770f47c9081a3de56b65314d2">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a9b78954271b6dba5e926bd960f3e7905">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ad4f7c62954f5c270e115d9b2a2df15ea">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a476f559a69eef5999c99cd6262a9aa2f">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8">emit</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#abdae39f9a7abd6133c03d65224c227d6">emit_reverse</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ac7eafdced2d325d6003327b4360bc2dd">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ad61e875748cf4e1c2a6d89a930ae093e">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a3295536428e5e0d6478ac10e2daff736">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a2dd3042c0681542ed6f2de5840f713a1">operator()</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a4e8311eac2fd7f8ecd10bff8225ed9e3">operator=</a>(const signal0 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a693aa3743236012416349bfac56d31b6">operator=</a>(signal0 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a1d9c390974304392ed12ee81543ab997">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a2fb24e11a8f645e5122646ea2b4a5d2f">signal0</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a7dc687f1afb4088a3d888aa05dbf56d9">signal0</a>(const signal0 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ac1b915a86d0b75fd4e90c2a92f7ebc49">signal0</a>(signal0 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#add195c1c738ee8efe10294f21d258b77">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a5576113ddfd6b92a96f86072262307f9">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a73523d71edd7fb4294324e9561db6f3c">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil >::accumulated< T_accumulator > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, nil, nil, nil, nil, nil, nil, nil ></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil >::accumulated< T_accumulator > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal0.html" title="Signal declaration.">sigc::signal0</a> template.
+ <a href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil >::accumulated< T_accumulator >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil1ce68760f5323ed9c9884b19387edf66.png" border="0" usemap="#asigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" id="asigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::signal0 template." alt="" coords="7,244,180,315"/>
+<area shape="rect" href="classsigc_1_1signal0.html" title=" " alt="" coords="5,155,181,196"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="27,80,160,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="35,5,151,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a54763bd7352a9c84b5e5956b4f65c914"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#a54763bd7352a9c84b5e5956b4f65c914">accumulated</a> ()</td></tr>
+<tr class="separator:a54763bd7352a9c84b5e5956b4f65c914"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1cea5890a6ac54f475ae28062c99e4f4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#a1cea5890a6ac54f475ae28062c99e4f4">accumulated</a> (const accumulated & src)</td></tr>
+<tr class="separator:a1cea5890a6ac54f475ae28062c99e4f4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal0"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal0')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td></tr>
+<tr class="memitem:a2fb24e11a8f645e5122646ea2b4a5d2f inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a2fb24e11a8f645e5122646ea2b4a5d2f">signal0</a> ()</td></tr>
+<tr class="separator:a2fb24e11a8f645e5122646ea2b4a5d2f inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7dc687f1afb4088a3d888aa05dbf56d9 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a7dc687f1afb4088a3d888aa05dbf56d9">signal0</a> (const <a class="el" href="classsigc_1_1signal0.html">signal0</a> & src)</td></tr>
+<tr class="separator:a7dc687f1afb4088a3d888aa05dbf56d9 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac1b915a86d0b75fd4e90c2a92f7ebc49 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ac1b915a86d0b75fd4e90c2a92f7ebc49">signal0</a> (<a class="el" href="classsigc_1_1signal0.html">signal0</a> && src)</td></tr>
+<tr class="separator:ac1b915a86d0b75fd4e90c2a92f7ebc49 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a609b1e0770f47c9081a3de56b65314d2 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#ad61e875748cf4e1c2a6d89a930ae093e">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a609b1e0770f47c9081a3de56b65314d2">connect</a> (const <a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:a609b1e0770f47c9081a3de56b65314d2 inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal0.html#a609b1e0770f47c9081a3de56b65314d2">More...</a><br /></td></tr>
+<tr class="separator:a609b1e0770f47c9081a3de56b65314d2 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9b78954271b6dba5e926bd960f3e7905 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#ad61e875748cf4e1c2a6d89a930ae093e">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a9b78954271b6dba5e926bd960f3e7905">connect</a> (<a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:a9b78954271b6dba5e926bd960f3e7905 inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal0.html#a9b78954271b6dba5e926bd960f3e7905">More...</a><br /></td></tr>
+<tr class="separator:a9b78954271b6dba5e926bd960f3e7905 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a655829125186645bcbc61db8252134a8 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8">emit</a> () const</td></tr>
+<tr class="memdesc:a655829125186645bcbc61db8252134a8 inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8">More...</a><br /></td></tr>
+<tr class="separator:a655829125186645bcbc61db8252134a8 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abdae39f9a7abd6133c03d65224c227d6 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#abdae39f9a7abd6133c03d65224c227d6">emit_reverse</a> () const</td></tr>
+<tr class="memdesc:abdae39f9a7abd6133c03d65224c227d6 inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal0.html#abdae39f9a7abd6133c03d65224c227d6">More...</a><br /></td></tr>
+<tr class="separator:abdae39f9a7abd6133c03d65224c227d6 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3295536428e5e0d6478ac10e2daff736 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html">bound_const_mem_functor0</a>< <a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a>, <a class="el" href="classsigc_1_1signal0.html">signal0</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a3295536428e5e0d6478ac10e2daff736">make_slot</a> () const</td></tr>
+<tr class="memdesc:a3295536428e5e0d6478ac10e2daff736 inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal0.html#a3295536428e5e0d6478ac10e2daff736">More...</a><br /></td></tr>
+<tr class="separator:a3295536428e5e0d6478ac10e2daff736 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2dd3042c0681542ed6f2de5840f713a1 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a2dd3042c0681542ed6f2de5840f713a1">operator()</a> () const</td></tr>
+<tr class="memdesc:a2dd3042c0681542ed6f2de5840f713a1 inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal0.html#a2dd3042c0681542ed6f2de5840f713a1">More...</a><br /></td></tr>
+<tr class="separator:a2dd3042c0681542ed6f2de5840f713a1 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4e8311eac2fd7f8ecd10bff8225ed9e3 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html">signal0</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a4e8311eac2fd7f8ecd10bff8225ed9e3">operator=</a> (const <a class="el" href="classsigc_1_1signal0.html">signal0</a> & src)</td></tr>
+<tr class="separator:a4e8311eac2fd7f8ecd10bff8225ed9e3 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a693aa3743236012416349bfac56d31b6 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html">signal0</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a693aa3743236012416349bfac56d31b6">operator=</a> (<a class="el" href="classsigc_1_1signal0.html">signal0</a> && src)</td></tr>
+<tr class="separator:a693aa3743236012416349bfac56d31b6 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5576113ddfd6b92a96f86072262307f9 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#add195c1c738ee8efe10294f21d258b77">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a5576113ddfd6b92a96f86072262307f9">slots</a> ()</td></tr>
+<tr class="memdesc:a5576113ddfd6b92a96f86072262307f9 inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal0.html#a5576113ddfd6b92a96f86072262307f9">More...</a><br /></td></tr>
+<tr class="separator:a5576113ddfd6b92a96f86072262307f9 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a73523d71edd7fb4294324e9561db6f3c inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal0.html#add195c1c738ee8efe10294f21d258b77">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a73523d71edd7fb4294324e9561db6f3c">slots</a> () const</td></tr>
+<tr class="memdesc:a73523d71edd7fb4294324e9561db6f3c inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal0.html#a73523d71edd7fb4294324e9561db6f3c">More...</a><br /></td></tr>
+<tr class="separator:a73523d71edd7fb4294324e9561db6f3c inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal0"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal0')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td></tr>
+<tr class="memitem:ad4f7c62954f5c270e115d9b2a2df15ea inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ad4f7c62954f5c270e115d9b2a2df15ea">const_iterator</a></td></tr>
+<tr class="separator:ad4f7c62954f5c270e115d9b2a2df15ea inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a476f559a69eef5999c99cd6262a9aa2f inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a476f559a69eef5999c99cd6262a9aa2f">const_reverse_iterator</a></td></tr>
+<tr class="separator:a476f559a69eef5999c99cd6262a9aa2f inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac7eafdced2d325d6003327b4360bc2dd inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit0< T_return, T_accumulator > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ac7eafdced2d325d6003327b4360bc2dd">emitter_type</a></td></tr>
+<tr class="separator:ac7eafdced2d325d6003327b4360bc2dd inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad61e875748cf4e1c2a6d89a930ae093e inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ad61e875748cf4e1c2a6d89a930ae093e">iterator</a></td></tr>
+<tr class="separator:ad61e875748cf4e1c2a6d89a930ae093e inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae291a90c83f8ad1cdcc7c2a4cdd958de inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a></td></tr>
+<tr class="separator:ae291a90c83f8ad1cdcc7c2a4cdd958de inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1d9c390974304392ed12ee81543ab997 inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a1d9c390974304392ed12ee81543ab997">reverse_iterator</a></td></tr>
+<tr class="separator:a1d9c390974304392ed12ee81543ab997 inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:add195c1c738ee8efe10294f21d258b77 inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#add195c1c738ee8efe10294f21d258b77">slot_list_type</a></td></tr>
+<tr class="separator:add195c1c738ee8efe10294f21d258b77 inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae3fc90cec344b6585979e77d2b359287 inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return()> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a></td></tr>
+<tr class="separator:ae3fc90cec344b6585979e77d2b359287 inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return><br />
+template <class T_accumulator><br />
+class sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil >::accumulated< T_accumulator ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal0.html" title="Signal declaration.">sigc::signal0</a> template. </p>
+<p>Like <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> but the additional template parameter <em>T_accumulator</em> defines the accumulator type that should be used. </p>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a54763bd7352a9c84b5e5956b4f65c914"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a54763bd7352a9c84b5e5956b4f65c914">◆ </a></span>accumulated() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a1cea5890a6ac54f475ae28062c99e4f4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1cea5890a6ac54f475ae28062c99e4f4">◆ </a></span>accumulated() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramtype">const accumulated & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil >" name="sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::signal0 template." alt="" coords="9,244,177,300"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal0.html" title=" " alt="" coords="5,155,181,196"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="27,80,160,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="35,5,151,32"/>
+</map>
--- /dev/null
+26ae97a18b87a72d2bf43845615d66b4
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)> Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#nested-classes">Classes</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_43a85650168eb762e1fb38ef04141702.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)> Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This specialization allow use of the sigc::signal<R(Args...)> syntax,.
+ <a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_ec3ac48ed12ed232a0dbee9db1100457.png" border="0" usemap="#asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4_inherit__map" id="asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4_inherit__map">
+<area shape="rect" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="577,5,756,76"/>
+<area shape="rect" href="classsigc_1_1signal7.html" title=" " alt="" coords="351,5,529,76"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="169,27,303,54"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="5,27,121,54"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Classes</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html">accumulated</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates. <a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:ac3cad4e400bacfc4a539cb7a31cd0e01"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html#ac3cad4e400bacfc4a539cb7a31cd0e01">signal</a> ()</td></tr>
+<tr class="separator:ac3cad4e400bacfc4a539cb7a31cd0e01"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9b9928bf9b40cae47599be1f4f7f85dc"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html#a9b9928bf9b40cae47599be1f4f7f85dc">signal</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:a9b9928bf9b40cae47599be1f4f7f85dc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5595334118f67137ded1af1720743da8"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html#a5595334118f67137ded1af1720743da8">signal</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:a5595334118f67137ded1af1720743da8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8fe96aaacf6a2d0780887623a6f2b15a"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html#a8fe96aaacf6a2d0780887623a6f2b15a">operator=</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:a8fe96aaacf6a2d0780887623a6f2b15a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aaa92f0fe77bca0af86a3a0ddd77bc96b"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html#aaa92f0fe77bca0af86a3a0ddd77bc96b">operator=</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:aaa92f0fe77bca0af86a3a0ddd77bc96b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal7"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal7')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil ></a></td></tr>
+<tr class="memitem:ab6d54db53a164fb459fcb342d4b45ff0 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#ab6d54db53a164fb459fcb342d4b45ff0">signal7</a> ()</td></tr>
+<tr class="separator:ab6d54db53a164fb459fcb342d4b45ff0 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a12d6e064d0a5c2a8c09d60a64184a823 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a12d6e064d0a5c2a8c09d60a64184a823">signal7</a> (const <a class="el" href="classsigc_1_1signal7.html">signal7</a> & src)</td></tr>
+<tr class="separator:a12d6e064d0a5c2a8c09d60a64184a823 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5a5893dd4f97d77b7945819f5ada2aee inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a5a5893dd4f97d77b7945819f5ada2aee">signal7</a> (<a class="el" href="classsigc_1_1signal7.html">signal7</a> && src)</td></tr>
+<tr class="separator:a5a5893dd4f97d77b7945819f5ada2aee inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adc55ac9b0f935fd87a67904022e03cb2 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">connect</a> (const <a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:adc55ac9b0f935fd87a67904022e03cb2 inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">More...</a><br /></td></tr>
+<tr class="separator:adc55ac9b0f935fd87a67904022e03cb2 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5aed4bdb8d85c3d854f01410d2d9d3a4 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a5aed4bdb8d85c3d854f01410d2d9d3a4">connect</a> (<a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:a5aed4bdb8d85c3d854f01410d2d9d3a4 inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal7.html#a5aed4bdb8d85c3d854f01410d2d9d3a4">More...</a><br /></td></tr>
+<tr class="separator:a5aed4bdb8d85c3d854f01410d2d9d3a4 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aead3b0e97ed0bd95f870b1956bff83c2 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:aead3b0e97ed0bd95f870b1956bff83c2 inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2">More...</a><br /></td></tr>
+<tr class="separator:aead3b0e97ed0bd95f870b1956bff83c2 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a192581feb2dbcfc9c56692e72e91e9a8 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a192581feb2dbcfc9c56692e72e91e9a8">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:a192581feb2dbcfc9c56692e72e91e9a8 inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal7.html#a192581feb2dbcfc9c56692e72e91e9a8">More...</a><br /></td></tr>
+<tr class="separator:a192581feb2dbcfc9c56692e72e91e9a8 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3f468c8b6cc55d675c75d0184bd8e38a inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html">bound_const_mem_functor7</a>< <a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a>, <a class="el" href="classsigc_1_1signal7.html">signal7</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a3f468c8b6cc55d675c75d0184bd8e38a">make_slot</a> () const</td></tr>
+<tr class="memdesc:a3f468c8b6cc55d675c75d0184bd8e38a inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal7.html#a3f468c8b6cc55d675c75d0184bd8e38a">More...</a><br /></td></tr>
+<tr class="separator:a3f468c8b6cc55d675c75d0184bd8e38a inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac6fd43215c8f19082402387359330071 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#ac6fd43215c8f19082402387359330071">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:ac6fd43215c8f19082402387359330071 inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal7.html#ac6fd43215c8f19082402387359330071">More...</a><br /></td></tr>
+<tr class="separator:ac6fd43215c8f19082402387359330071 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af8a93a4c8fb0b78fa6578e7dc95f5751 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html">signal7</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#af8a93a4c8fb0b78fa6578e7dc95f5751">operator=</a> (const <a class="el" href="classsigc_1_1signal7.html">signal7</a> & src)</td></tr>
+<tr class="separator:af8a93a4c8fb0b78fa6578e7dc95f5751 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac06938f5cb6ff60a1bd5eaa32c990eea inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html">signal7</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#ac06938f5cb6ff60a1bd5eaa32c990eea">operator=</a> (<a class="el" href="classsigc_1_1signal7.html">signal7</a> && src)</td></tr>
+<tr class="separator:ac06938f5cb6ff60a1bd5eaa32c990eea inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a68153d9079b4881352113079cd6216f7 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a68153d9079b4881352113079cd6216f7">slots</a> ()</td></tr>
+<tr class="memdesc:a68153d9079b4881352113079cd6216f7 inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal7.html#a68153d9079b4881352113079cd6216f7">More...</a><br /></td></tr>
+<tr class="separator:a68153d9079b4881352113079cd6216f7 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a42509108239296e424844df2cd330aca inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a42509108239296e424844df2cd330aca">slots</a> () const</td></tr>
+<tr class="memdesc:a42509108239296e424844df2cd330aca inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal7.html#a42509108239296e424844df2cd330aca">More...</a><br /></td></tr>
+<tr class="separator:a42509108239296e424844df2cd330aca inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal7"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal7')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil ></a></td></tr>
+<tr class="memitem:a6eef6225eba66a86dd32c3f3b79845f7 inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a6eef6225eba66a86dd32c3f3b79845f7">const_iterator</a></td></tr>
+<tr class="separator:a6eef6225eba66a86dd32c3f3b79845f7 inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1ba32ad7dae0c05a4012ada78077505 inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#ad1ba32ad7dae0c05a4012ada78077505">const_reverse_iterator</a></td></tr>
+<tr class="separator:ad1ba32ad7dae0c05a4012ada78077505 inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7fa856e67a31c86538db7c289a6870e3 inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, <a class="el" href="structsigc_1_1nil.html">nil</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a7fa856e67a31c86538db7c289a6870e3">emitter_type</a></td></tr>
+<tr class="separator:a7fa856e67a31c86538db7c289a6870e3 inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abc62e52cc684f917577a2fe3cd914d4a inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a">iterator</a></td></tr>
+<tr class="separator:abc62e52cc684f917577a2fe3cd914d4a inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5a75d73a254cf91a0f3ad1cd3545e29f inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a></td></tr>
+<tr class="separator:a5a75d73a254cf91a0f3ad1cd3545e29f inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a59c9c9fee7a98528839df592241351a9 inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a59c9c9fee7a98528839df592241351a9">reverse_iterator</a></td></tr>
+<tr class="separator:a59c9c9fee7a98528839df592241351a9 inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a79686c2174ab01dc23394953955ff003 inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003">slot_list_type</a></td></tr>
+<tr class="separator:a79686c2174ab01dc23394953955ff003 inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a72ee8c51eea3d1ba99eb9b512dfccd81 inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a></td></tr>
+<tr class="separator:a72ee8c51eea3d1ba99eb9b512dfccd81 inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7><br />
+class sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)></h3>
+
+<p>This specialization allow use of the sigc::signal<R(Args...)> syntax,. </p>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="ac3cad4e400bacfc4a539cb7a31cd0e01"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac3cad4e400bacfc4a539cb7a31cd0e01">◆ </a></span>signal() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a9b9928bf9b40cae47599be1f4f7f85dc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9b9928bf9b40cae47599be1f4f7f85dc">◆ </a></span>signal() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)> & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a5595334118f67137ded1af1720743da8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5595334118f67137ded1af1720743da8">◆ </a></span>signal() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)> && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a8fe96aaacf6a2d0780887623a6f2b15a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8fe96aaacf6a2d0780887623a6f2b15a">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)> & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aaa92f0fe77bca0af86a3a0ddd77bc96b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aaa92f0fe77bca0af86a3a0ddd77bc96b">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)> && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)> Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a66c302607cf4fb74f5d3352f9c394c9b">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a1754aa5a8959da0bb55e42864a8365af">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#ac88a9c4e9bab5ad04c66d3f5d3978f0f">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#aff490e7f75a83aa2f324a859f9071a79">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a2e8b355902f0646fb34b52b495123167">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#acdd2683223e4701f58350152f32f4488">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a1acee11287974cdac1bc63c856e5331d">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a97ae4180e80ac60b564fec58d1732317">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#affec011fd6e9605f10e50fdd4db424d8">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html#ad93fa9a04fa76e3133adb4361981c5cd">operator=</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html#a249b8264efb4167bf468a6b4c01fe6b5">operator=</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#ad7a4ab249b17bffccbfe441aa1420dd9">signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::operator=</a>(const signal6 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a012b9abce888e420e1b5b3f29aa98900">signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::operator=</a>(signal6 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a79b741b3f0def8f52fc185ad50b60673">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html#a6ec07b9037eeeab8094beb440d80407b">signal</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html#a975a2a33c137e6b662a31933d80563d6">signal</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html#a16f865ba75270a1808ed8f3a37e53a48">signal</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#af7f529bbd9cf26d468ed18426b9b51ea">signal6</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a0244dde296bd892c590c86ced5281e3b">signal6</a>(const signal6 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#ab717ce413bda79e1de41944d0675a8ca">signal6</a>(signal6 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a0e4fea9bd1ed35f9d60bbc26c4fae007">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#af44115a7bfa4586fc5312259a1df9567">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#ac66109f683ae86898ae10109a80b28a4">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)> Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#nested-classes">Classes</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)> Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This specialization allow use of the sigc::signal<R(Args...)> syntax,.
+ <a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dad4637e1583b021127592e90441ec81.png" border="0" usemap="#asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4_inherit__map" id="asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4_inherit__map">
+<area shape="rect" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="17,259,207,315"/>
+<area shape="rect" href="classsigc_1_1signal6.html" title=" " alt="" coords="5,155,219,211"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="45,80,179,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="54,5,170,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Classes</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html">accumulated</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal6.html" title="Signal declaration.">sigc::signal6</a> template. <a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a6ec07b9037eeeab8094beb440d80407b"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html#a6ec07b9037eeeab8094beb440d80407b">signal</a> ()</td></tr>
+<tr class="separator:a6ec07b9037eeeab8094beb440d80407b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a975a2a33c137e6b662a31933d80563d6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html#a975a2a33c137e6b662a31933d80563d6">signal</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:a975a2a33c137e6b662a31933d80563d6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a16f865ba75270a1808ed8f3a37e53a48"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html#a16f865ba75270a1808ed8f3a37e53a48">signal</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:a16f865ba75270a1808ed8f3a37e53a48"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad93fa9a04fa76e3133adb4361981c5cd"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html#ad93fa9a04fa76e3133adb4361981c5cd">operator=</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:ad93fa9a04fa76e3133adb4361981c5cd"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a249b8264efb4167bf468a6b4c01fe6b5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html#a249b8264efb4167bf468a6b4c01fe6b5">operator=</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:a249b8264efb4167bf468a6b4c01fe6b5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal6"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal6')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td></tr>
+<tr class="memitem:af7f529bbd9cf26d468ed18426b9b51ea inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#af7f529bbd9cf26d468ed18426b9b51ea">signal6</a> ()</td></tr>
+<tr class="separator:af7f529bbd9cf26d468ed18426b9b51ea inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0244dde296bd892c590c86ced5281e3b inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a0244dde296bd892c590c86ced5281e3b">signal6</a> (const <a class="el" href="classsigc_1_1signal6.html">signal6</a> & src)</td></tr>
+<tr class="separator:a0244dde296bd892c590c86ced5281e3b inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab717ce413bda79e1de41944d0675a8ca inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#ab717ce413bda79e1de41944d0675a8ca">signal6</a> (<a class="el" href="classsigc_1_1signal6.html">signal6</a> && src)</td></tr>
+<tr class="separator:ab717ce413bda79e1de41944d0675a8ca inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a66c302607cf4fb74f5d3352f9c394c9b inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a1acee11287974cdac1bc63c856e5331d">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a66c302607cf4fb74f5d3352f9c394c9b">connect</a> (const <a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:a66c302607cf4fb74f5d3352f9c394c9b inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal6.html#a66c302607cf4fb74f5d3352f9c394c9b">More...</a><br /></td></tr>
+<tr class="separator:a66c302607cf4fb74f5d3352f9c394c9b inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1754aa5a8959da0bb55e42864a8365af inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a1acee11287974cdac1bc63c856e5331d">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a1754aa5a8959da0bb55e42864a8365af">connect</a> (<a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:a1754aa5a8959da0bb55e42864a8365af inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal6.html#a1754aa5a8959da0bb55e42864a8365af">More...</a><br /></td></tr>
+<tr class="separator:a1754aa5a8959da0bb55e42864a8365af inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a6361a9230323e7c7e86e2c9e6c8fe21b inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:a6361a9230323e7c7e86e2c9e6c8fe21b inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b">More...</a><br /></td></tr>
+<tr class="separator:a6361a9230323e7c7e86e2c9e6c8fe21b inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2e8b355902f0646fb34b52b495123167 inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a2e8b355902f0646fb34b52b495123167">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:a2e8b355902f0646fb34b52b495123167 inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal6.html#a2e8b355902f0646fb34b52b495123167">More...</a><br /></td></tr>
+<tr class="separator:a2e8b355902f0646fb34b52b495123167 inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a97ae4180e80ac60b564fec58d1732317 inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html">bound_const_mem_functor6</a>< <a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a>, <a class="el" href="classsigc_1_1signal6.html">signal6</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a97ae4180e80ac60b564fec58d1732317">make_slot</a> () const</td></tr>
+<tr class="memdesc:a97ae4180e80ac60b564fec58d1732317 inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal6.html#a97ae4180e80ac60b564fec58d1732317">More...</a><br /></td></tr>
+<tr class="separator:a97ae4180e80ac60b564fec58d1732317 inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:affec011fd6e9605f10e50fdd4db424d8 inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#affec011fd6e9605f10e50fdd4db424d8">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:affec011fd6e9605f10e50fdd4db424d8 inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal6.html#affec011fd6e9605f10e50fdd4db424d8">More...</a><br /></td></tr>
+<tr class="separator:affec011fd6e9605f10e50fdd4db424d8 inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad7a4ab249b17bffccbfe441aa1420dd9 inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html">signal6</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#ad7a4ab249b17bffccbfe441aa1420dd9">operator=</a> (const <a class="el" href="classsigc_1_1signal6.html">signal6</a> & src)</td></tr>
+<tr class="separator:ad7a4ab249b17bffccbfe441aa1420dd9 inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a012b9abce888e420e1b5b3f29aa98900 inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html">signal6</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a012b9abce888e420e1b5b3f29aa98900">operator=</a> (<a class="el" href="classsigc_1_1signal6.html">signal6</a> && src)</td></tr>
+<tr class="separator:a012b9abce888e420e1b5b3f29aa98900 inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af44115a7bfa4586fc5312259a1df9567 inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a0e4fea9bd1ed35f9d60bbc26c4fae007">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#af44115a7bfa4586fc5312259a1df9567">slots</a> ()</td></tr>
+<tr class="memdesc:af44115a7bfa4586fc5312259a1df9567 inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal6.html#af44115a7bfa4586fc5312259a1df9567">More...</a><br /></td></tr>
+<tr class="separator:af44115a7bfa4586fc5312259a1df9567 inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac66109f683ae86898ae10109a80b28a4 inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal6.html#a0e4fea9bd1ed35f9d60bbc26c4fae007">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#ac66109f683ae86898ae10109a80b28a4">slots</a> () const</td></tr>
+<tr class="memdesc:ac66109f683ae86898ae10109a80b28a4 inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal6.html#ac66109f683ae86898ae10109a80b28a4">More...</a><br /></td></tr>
+<tr class="separator:ac66109f683ae86898ae10109a80b28a4 inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal6"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal6')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td></tr>
+<tr class="memitem:ac88a9c4e9bab5ad04c66d3f5d3978f0f inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#ac88a9c4e9bab5ad04c66d3f5d3978f0f">const_iterator</a></td></tr>
+<tr class="separator:ac88a9c4e9bab5ad04c66d3f5d3978f0f inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aff490e7f75a83aa2f324a859f9071a79 inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#aff490e7f75a83aa2f324a859f9071a79">const_reverse_iterator</a></td></tr>
+<tr class="separator:aff490e7f75a83aa2f324a859f9071a79 inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acdd2683223e4701f58350152f32f4488 inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, <a class="el" href="structsigc_1_1nil.html">nil</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#acdd2683223e4701f58350152f32f4488">emitter_type</a></td></tr>
+<tr class="separator:acdd2683223e4701f58350152f32f4488 inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1acee11287974cdac1bc63c856e5331d inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a1acee11287974cdac1bc63c856e5331d">iterator</a></td></tr>
+<tr class="separator:a1acee11287974cdac1bc63c856e5331d inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a56f1acca230e676dae665d41a10acc8f inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a></td></tr>
+<tr class="separator:a56f1acca230e676dae665d41a10acc8f inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a79b741b3f0def8f52fc185ad50b60673 inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a79b741b3f0def8f52fc185ad50b60673">reverse_iterator</a></td></tr>
+<tr class="separator:a79b741b3f0def8f52fc185ad50b60673 inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0e4fea9bd1ed35f9d60bbc26c4fae007 inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a0e4fea9bd1ed35f9d60bbc26c4fae007">slot_list_type</a></td></tr>
+<tr class="separator:a0e4fea9bd1ed35f9d60bbc26c4fae007 inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac62cdf4db7dcd5e30975e51e978f03db inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a></td></tr>
+<tr class="separator:ac62cdf4db7dcd5e30975e51e978f03db inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6><br />
+class sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)></h3>
+
+<p>This specialization allow use of the sigc::signal<R(Args...)> syntax,. </p>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a6ec07b9037eeeab8094beb440d80407b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a6ec07b9037eeeab8094beb440d80407b">◆ </a></span>signal() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a975a2a33c137e6b662a31933d80563d6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a975a2a33c137e6b662a31933d80563d6">◆ </a></span>signal() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)> & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a16f865ba75270a1808ed8f3a37e53a48"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a16f865ba75270a1808ed8f3a37e53a48">◆ </a></span>signal() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)> && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="ad93fa9a04fa76e3133adb4361981c5cd"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad93fa9a04fa76e3133adb4361981c5cd">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)> & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a249b8264efb4167bf468a6b4c01fe6b5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a249b8264efb4167bf468a6b4c01fe6b5">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)> && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)> Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a057789cc27a920700e240f8f3d78dd65">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a05cfed3d3e29158424bc810168d78153">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a17e79eed46f178a12d2751eddcf85290">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#ad5ba46907fe236e0cff806888696d569">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#aa6d2e202263e3879f0d3949612d7fcdf">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a7d77e5fa748b024842bf92e28cf0f4ab">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#acee689b441305fcee098345729fc28f3">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a7b01481c87d4ec9c03095e76cb502c24">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a7a5bb7b92f49e99354caf50bfef16907">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html#ac3fd7b8ac2caf93330629a3caa000d57">operator=</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html#a95b7d55776c477cae58859f01a043d6e">operator=</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a2c3d9a6d8b499da389672f44f8044ce6">signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil >::operator=</a>(const signal5 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a5c652f8e549a2c555b79db8e8a05f407">signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil >::operator=</a>(signal5 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#ab684cb9920d0f7949f28c03d50b58275">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html#a7006442d66ee8f812ffdff15cd5694a3">signal</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html#a7d61f31c6577339602b629bff20f0248">signal</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html#a016fcefe1eb805926dafad10f970f826">signal</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#af717d1a6fd8612da84dce33fe6640b7a">signal5</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a7885861b9cdbacbe2d58a13cd96ec265">signal5</a>(const signal5 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#af39141aeec9dc870dd28926202493de4">signal5</a>(signal5 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a4c79ab227fc3b31b990e925636f7788e">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#ad6a4ae2a214d8710be6e36bb425587fc">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a32af276c9c56abbb0386f54262b40be5">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)> Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#nested-classes">Classes</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)> Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This specialization allow use of the sigc::signal<R(Args...)> syntax,.
+ <a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4__inherit__graph.png" border="0" usemap="#asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_inherit__map" id="asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_inherit__map">
+<area shape="rect" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="5,259,184,315"/>
+<area shape="rect" href="classsigc_1_1signal5.html" title=" " alt="" coords="5,155,184,211"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="28,80,161,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="37,5,153,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Classes</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html">accumulated</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal5.html" title="Signal declaration.">sigc::signal5</a> template. <a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a7006442d66ee8f812ffdff15cd5694a3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html#a7006442d66ee8f812ffdff15cd5694a3">signal</a> ()</td></tr>
+<tr class="separator:a7006442d66ee8f812ffdff15cd5694a3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7d61f31c6577339602b629bff20f0248"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html#a7d61f31c6577339602b629bff20f0248">signal</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:a7d61f31c6577339602b629bff20f0248"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a016fcefe1eb805926dafad10f970f826"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html#a016fcefe1eb805926dafad10f970f826">signal</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:a016fcefe1eb805926dafad10f970f826"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3fd7b8ac2caf93330629a3caa000d57"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html#ac3fd7b8ac2caf93330629a3caa000d57">operator=</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:ac3fd7b8ac2caf93330629a3caa000d57"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a95b7d55776c477cae58859f01a043d6e"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html#a95b7d55776c477cae58859f01a043d6e">operator=</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:a95b7d55776c477cae58859f01a043d6e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal5"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal5')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td></tr>
+<tr class="memitem:af717d1a6fd8612da84dce33fe6640b7a inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#af717d1a6fd8612da84dce33fe6640b7a">signal5</a> ()</td></tr>
+<tr class="separator:af717d1a6fd8612da84dce33fe6640b7a inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7885861b9cdbacbe2d58a13cd96ec265 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a7885861b9cdbacbe2d58a13cd96ec265">signal5</a> (const <a class="el" href="classsigc_1_1signal5.html">signal5</a> & src)</td></tr>
+<tr class="separator:a7885861b9cdbacbe2d58a13cd96ec265 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af39141aeec9dc870dd28926202493de4 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#af39141aeec9dc870dd28926202493de4">signal5</a> (<a class="el" href="classsigc_1_1signal5.html">signal5</a> && src)</td></tr>
+<tr class="separator:af39141aeec9dc870dd28926202493de4 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a057789cc27a920700e240f8f3d78dd65 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#acee689b441305fcee098345729fc28f3">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a057789cc27a920700e240f8f3d78dd65">connect</a> (const <a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:a057789cc27a920700e240f8f3d78dd65 inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal5.html#a057789cc27a920700e240f8f3d78dd65">More...</a><br /></td></tr>
+<tr class="separator:a057789cc27a920700e240f8f3d78dd65 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a05cfed3d3e29158424bc810168d78153 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#acee689b441305fcee098345729fc28f3">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a05cfed3d3e29158424bc810168d78153">connect</a> (<a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:a05cfed3d3e29158424bc810168d78153 inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal5.html#a05cfed3d3e29158424bc810168d78153">More...</a><br /></td></tr>
+<tr class="separator:a05cfed3d3e29158424bc810168d78153 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8772fef879632c4ff45e82b4b00b0157 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:a8772fef879632c4ff45e82b4b00b0157 inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157">More...</a><br /></td></tr>
+<tr class="separator:a8772fef879632c4ff45e82b4b00b0157 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa6d2e202263e3879f0d3949612d7fcdf inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#aa6d2e202263e3879f0d3949612d7fcdf">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:aa6d2e202263e3879f0d3949612d7fcdf inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal5.html#aa6d2e202263e3879f0d3949612d7fcdf">More...</a><br /></td></tr>
+<tr class="separator:aa6d2e202263e3879f0d3949612d7fcdf inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7b01481c87d4ec9c03095e76cb502c24 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html">bound_const_mem_functor5</a>< <a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a>, <a class="el" href="classsigc_1_1signal5.html">signal5</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a7b01481c87d4ec9c03095e76cb502c24">make_slot</a> () const</td></tr>
+<tr class="memdesc:a7b01481c87d4ec9c03095e76cb502c24 inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal5.html#a7b01481c87d4ec9c03095e76cb502c24">More...</a><br /></td></tr>
+<tr class="separator:a7b01481c87d4ec9c03095e76cb502c24 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7a5bb7b92f49e99354caf50bfef16907 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a7a5bb7b92f49e99354caf50bfef16907">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:a7a5bb7b92f49e99354caf50bfef16907 inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal5.html#a7a5bb7b92f49e99354caf50bfef16907">More...</a><br /></td></tr>
+<tr class="separator:a7a5bb7b92f49e99354caf50bfef16907 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2c3d9a6d8b499da389672f44f8044ce6 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html">signal5</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a2c3d9a6d8b499da389672f44f8044ce6">operator=</a> (const <a class="el" href="classsigc_1_1signal5.html">signal5</a> & src)</td></tr>
+<tr class="separator:a2c3d9a6d8b499da389672f44f8044ce6 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5c652f8e549a2c555b79db8e8a05f407 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html">signal5</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a5c652f8e549a2c555b79db8e8a05f407">operator=</a> (<a class="el" href="classsigc_1_1signal5.html">signal5</a> && src)</td></tr>
+<tr class="separator:a5c652f8e549a2c555b79db8e8a05f407 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad6a4ae2a214d8710be6e36bb425587fc inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#a4c79ab227fc3b31b990e925636f7788e">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#ad6a4ae2a214d8710be6e36bb425587fc">slots</a> ()</td></tr>
+<tr class="memdesc:ad6a4ae2a214d8710be6e36bb425587fc inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal5.html#ad6a4ae2a214d8710be6e36bb425587fc">More...</a><br /></td></tr>
+<tr class="separator:ad6a4ae2a214d8710be6e36bb425587fc inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a32af276c9c56abbb0386f54262b40be5 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal5.html#a4c79ab227fc3b31b990e925636f7788e">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a32af276c9c56abbb0386f54262b40be5">slots</a> () const</td></tr>
+<tr class="memdesc:a32af276c9c56abbb0386f54262b40be5 inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal5.html#a32af276c9c56abbb0386f54262b40be5">More...</a><br /></td></tr>
+<tr class="separator:a32af276c9c56abbb0386f54262b40be5 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal5"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal5')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td></tr>
+<tr class="memitem:a17e79eed46f178a12d2751eddcf85290 inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a17e79eed46f178a12d2751eddcf85290">const_iterator</a></td></tr>
+<tr class="separator:a17e79eed46f178a12d2751eddcf85290 inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad5ba46907fe236e0cff806888696d569 inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#ad5ba46907fe236e0cff806888696d569">const_reverse_iterator</a></td></tr>
+<tr class="separator:ad5ba46907fe236e0cff806888696d569 inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7d77e5fa748b024842bf92e28cf0f4ab inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, <a class="el" href="structsigc_1_1nil.html">nil</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a7d77e5fa748b024842bf92e28cf0f4ab">emitter_type</a></td></tr>
+<tr class="separator:a7d77e5fa748b024842bf92e28cf0f4ab inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acee689b441305fcee098345729fc28f3 inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#acee689b441305fcee098345729fc28f3">iterator</a></td></tr>
+<tr class="separator:acee689b441305fcee098345729fc28f3 inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aceb959897dcf8e3c7209c283d4848b94 inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a></td></tr>
+<tr class="separator:aceb959897dcf8e3c7209c283d4848b94 inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab684cb9920d0f7949f28c03d50b58275 inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#ab684cb9920d0f7949f28c03d50b58275">reverse_iterator</a></td></tr>
+<tr class="separator:ab684cb9920d0f7949f28c03d50b58275 inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4c79ab227fc3b31b990e925636f7788e inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a4c79ab227fc3b31b990e925636f7788e">slot_list_type</a></td></tr>
+<tr class="separator:a4c79ab227fc3b31b990e925636f7788e inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae73737aad5d854c6466e8b13e7963b9e inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a></td></tr>
+<tr class="separator:ae73737aad5d854c6466e8b13e7963b9e inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5><br />
+class sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)></h3>
+
+<p>This specialization allow use of the sigc::signal<R(Args...)> syntax,. </p>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a7006442d66ee8f812ffdff15cd5694a3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7006442d66ee8f812ffdff15cd5694a3">◆ </a></span>signal() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a7d61f31c6577339602b629bff20f0248"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7d61f31c6577339602b629bff20f0248">◆ </a></span>signal() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)> & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a016fcefe1eb805926dafad10f970f826"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a016fcefe1eb805926dafad10f970f826">◆ </a></span>signal() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)> && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="ac3fd7b8ac2caf93330629a3caa000d57"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac3fd7b8ac2caf93330629a3caa000d57">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)> & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a95b7d55776c477cae58859f01a043d6e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a95b7d55776c477cae58859f01a043d6e">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)> && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::accumulated< T_accumulator > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::accumulated< T_accumulator ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html#a77a966e973f4ab159f0dbb92737dd02e">accumulated</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html#a3b820b8e12b845648ff1eeff72bf97fa">accumulated</a>(const accumulated & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a057789cc27a920700e240f8f3d78dd65">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a05cfed3d3e29158424bc810168d78153">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a17e79eed46f178a12d2751eddcf85290">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#ad5ba46907fe236e0cff806888696d569">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#aa6d2e202263e3879f0d3949612d7fcdf">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a7d77e5fa748b024842bf92e28cf0f4ab">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#acee689b441305fcee098345729fc28f3">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a7b01481c87d4ec9c03095e76cb502c24">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a7a5bb7b92f49e99354caf50bfef16907">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a2c3d9a6d8b499da389672f44f8044ce6">operator=</a>(const signal5 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a5c652f8e549a2c555b79db8e8a05f407">operator=</a>(signal5 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#ab684cb9920d0f7949f28c03d50b58275">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#af717d1a6fd8612da84dce33fe6640b7a">signal5</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a7885861b9cdbacbe2d58a13cd96ec265">signal5</a>(const signal5 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#af39141aeec9dc870dd28926202493de4">signal5</a>(signal5 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a4c79ab227fc3b31b990e925636f7788e">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal5.html#ad6a4ae2a214d8710be6e36bb425587fc">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal5.html#a32af276c9c56abbb0386f54262b40be5">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::accumulated< T_accumulator > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::accumulated< T_accumulator > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal5.html" title="Signal declaration.">sigc::signal5</a> template.
+ <a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::accumulated< T_accumulator >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_85d3e6b61106bb00a1c560939ede9003.png" border="0" usemap="#asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" id="asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::signal5 template." alt="" coords="11,259,241,329"/>
+<area shape="rect" href="classsigc_1_1signal5.html" title=" " alt="" coords="5,155,247,211"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="59,80,193,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="68,5,184,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a77a966e973f4ab159f0dbb92737dd02e"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html#a77a966e973f4ab159f0dbb92737dd02e">accumulated</a> ()</td></tr>
+<tr class="separator:a77a966e973f4ab159f0dbb92737dd02e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3b820b8e12b845648ff1eeff72bf97fa"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html#a3b820b8e12b845648ff1eeff72bf97fa">accumulated</a> (const accumulated & src)</td></tr>
+<tr class="separator:a3b820b8e12b845648ff1eeff72bf97fa"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal5"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal5')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td></tr>
+<tr class="memitem:af717d1a6fd8612da84dce33fe6640b7a inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#af717d1a6fd8612da84dce33fe6640b7a">signal5</a> ()</td></tr>
+<tr class="separator:af717d1a6fd8612da84dce33fe6640b7a inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7885861b9cdbacbe2d58a13cd96ec265 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a7885861b9cdbacbe2d58a13cd96ec265">signal5</a> (const <a class="el" href="classsigc_1_1signal5.html">signal5</a> & src)</td></tr>
+<tr class="separator:a7885861b9cdbacbe2d58a13cd96ec265 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af39141aeec9dc870dd28926202493de4 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#af39141aeec9dc870dd28926202493de4">signal5</a> (<a class="el" href="classsigc_1_1signal5.html">signal5</a> && src)</td></tr>
+<tr class="separator:af39141aeec9dc870dd28926202493de4 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a057789cc27a920700e240f8f3d78dd65 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#acee689b441305fcee098345729fc28f3">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a057789cc27a920700e240f8f3d78dd65">connect</a> (const <a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:a057789cc27a920700e240f8f3d78dd65 inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal5.html#a057789cc27a920700e240f8f3d78dd65">More...</a><br /></td></tr>
+<tr class="separator:a057789cc27a920700e240f8f3d78dd65 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a05cfed3d3e29158424bc810168d78153 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#acee689b441305fcee098345729fc28f3">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a05cfed3d3e29158424bc810168d78153">connect</a> (<a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:a05cfed3d3e29158424bc810168d78153 inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal5.html#a05cfed3d3e29158424bc810168d78153">More...</a><br /></td></tr>
+<tr class="separator:a05cfed3d3e29158424bc810168d78153 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8772fef879632c4ff45e82b4b00b0157 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:a8772fef879632c4ff45e82b4b00b0157 inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157">More...</a><br /></td></tr>
+<tr class="separator:a8772fef879632c4ff45e82b4b00b0157 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa6d2e202263e3879f0d3949612d7fcdf inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#aa6d2e202263e3879f0d3949612d7fcdf">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:aa6d2e202263e3879f0d3949612d7fcdf inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal5.html#aa6d2e202263e3879f0d3949612d7fcdf">More...</a><br /></td></tr>
+<tr class="separator:aa6d2e202263e3879f0d3949612d7fcdf inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7b01481c87d4ec9c03095e76cb502c24 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html">bound_const_mem_functor5</a>< <a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a>, <a class="el" href="classsigc_1_1signal5.html">signal5</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a7b01481c87d4ec9c03095e76cb502c24">make_slot</a> () const</td></tr>
+<tr class="memdesc:a7b01481c87d4ec9c03095e76cb502c24 inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal5.html#a7b01481c87d4ec9c03095e76cb502c24">More...</a><br /></td></tr>
+<tr class="separator:a7b01481c87d4ec9c03095e76cb502c24 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7a5bb7b92f49e99354caf50bfef16907 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a7a5bb7b92f49e99354caf50bfef16907">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:a7a5bb7b92f49e99354caf50bfef16907 inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal5.html#a7a5bb7b92f49e99354caf50bfef16907">More...</a><br /></td></tr>
+<tr class="separator:a7a5bb7b92f49e99354caf50bfef16907 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2c3d9a6d8b499da389672f44f8044ce6 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html">signal5</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a2c3d9a6d8b499da389672f44f8044ce6">operator=</a> (const <a class="el" href="classsigc_1_1signal5.html">signal5</a> & src)</td></tr>
+<tr class="separator:a2c3d9a6d8b499da389672f44f8044ce6 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5c652f8e549a2c555b79db8e8a05f407 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html">signal5</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a5c652f8e549a2c555b79db8e8a05f407">operator=</a> (<a class="el" href="classsigc_1_1signal5.html">signal5</a> && src)</td></tr>
+<tr class="separator:a5c652f8e549a2c555b79db8e8a05f407 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad6a4ae2a214d8710be6e36bb425587fc inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal5.html#a4c79ab227fc3b31b990e925636f7788e">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#ad6a4ae2a214d8710be6e36bb425587fc">slots</a> ()</td></tr>
+<tr class="memdesc:ad6a4ae2a214d8710be6e36bb425587fc inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal5.html#ad6a4ae2a214d8710be6e36bb425587fc">More...</a><br /></td></tr>
+<tr class="separator:ad6a4ae2a214d8710be6e36bb425587fc inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a32af276c9c56abbb0386f54262b40be5 inherit pub_methods_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal5.html#a4c79ab227fc3b31b990e925636f7788e">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a32af276c9c56abbb0386f54262b40be5">slots</a> () const</td></tr>
+<tr class="memdesc:a32af276c9c56abbb0386f54262b40be5 inherit pub_methods_classsigc_1_1signal5"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal5.html#a32af276c9c56abbb0386f54262b40be5">More...</a><br /></td></tr>
+<tr class="separator:a32af276c9c56abbb0386f54262b40be5 inherit pub_methods_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal5"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal5')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td></tr>
+<tr class="memitem:a17e79eed46f178a12d2751eddcf85290 inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a17e79eed46f178a12d2751eddcf85290">const_iterator</a></td></tr>
+<tr class="separator:a17e79eed46f178a12d2751eddcf85290 inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad5ba46907fe236e0cff806888696d569 inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#ad5ba46907fe236e0cff806888696d569">const_reverse_iterator</a></td></tr>
+<tr class="separator:ad5ba46907fe236e0cff806888696d569 inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7d77e5fa748b024842bf92e28cf0f4ab inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a7d77e5fa748b024842bf92e28cf0f4ab">emitter_type</a></td></tr>
+<tr class="separator:a7d77e5fa748b024842bf92e28cf0f4ab inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acee689b441305fcee098345729fc28f3 inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#acee689b441305fcee098345729fc28f3">iterator</a></td></tr>
+<tr class="separator:acee689b441305fcee098345729fc28f3 inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aceb959897dcf8e3c7209c283d4848b94 inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">result_type</a></td></tr>
+<tr class="separator:aceb959897dcf8e3c7209c283d4848b94 inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab684cb9920d0f7949f28c03d50b58275 inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#ab684cb9920d0f7949f28c03d50b58275">reverse_iterator</a></td></tr>
+<tr class="separator:ab684cb9920d0f7949f28c03d50b58275 inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4c79ab227fc3b31b990e925636f7788e inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#a4c79ab227fc3b31b990e925636f7788e">slot_list_type</a></td></tr>
+<tr class="separator:a4c79ab227fc3b31b990e925636f7788e inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae73737aad5d854c6466e8b13e7963b9e inherit pub_types_classsigc_1_1signal5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">slot_type</a></td></tr>
+<tr class="separator:ae73737aad5d854c6466e8b13e7963b9e inherit pub_types_classsigc_1_1signal5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5><br />
+template <class T_accumulator><br />
+class sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::accumulated< T_accumulator ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal5.html" title="Signal declaration.">sigc::signal5</a> template. </p>
+<p>Like <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> but the additional template parameter <em>T_accumulator</em> defines the accumulator type that should be used. </p>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a77a966e973f4ab159f0dbb92737dd02e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a77a966e973f4ab159f0dbb92737dd02e">◆ </a></span>accumulated() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a3b820b8e12b845648ff1eeff72bf97fa"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3b820b8e12b845648ff1eeff72bf97fa">◆ </a></span>accumulated() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramtype">const accumulated & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>" name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>">
+<area shape="rect" id="node1" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="5,259,184,315"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal5.html" title=" " alt="" coords="5,155,184,211"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="28,80,161,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="37,5,153,32"/>
+</map>
--- /dev/null
+570dd2a76c99ebd9e67973e82e4c3d96
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::accumulated< T_accumulator > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::accumulated< T_accumulator ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html#a33552c46e4db86b98bea128fd32d2c08">accumulated</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html#afc104f4e3d7a445cf4f7989c52f1d93c">accumulated</a>(const accumulated & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a5aed4bdb8d85c3d854f01410d2d9d3a4">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a6eef6225eba66a86dd32c3f3b79845f7">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#ad1ba32ad7dae0c05a4012ada78077505">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a192581feb2dbcfc9c56692e72e91e9a8">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a7fa856e67a31c86538db7c289a6870e3">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a3f468c8b6cc55d675c75d0184bd8e38a">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#ac6fd43215c8f19082402387359330071">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#af8a93a4c8fb0b78fa6578e7dc95f5751">operator=</a>(const signal7 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#ac06938f5cb6ff60a1bd5eaa32c990eea">operator=</a>(signal7 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a59c9c9fee7a98528839df592241351a9">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#ab6d54db53a164fb459fcb342d4b45ff0">signal7</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a12d6e064d0a5c2a8c09d60a64184a823">signal7</a>(const signal7 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a5a5893dd4f97d77b7945819f5ada2aee">signal7</a>(signal7 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a68153d9079b4881352113079cd6216f7">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a42509108239296e424844df2cd330aca">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)> Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a5aed4bdb8d85c3d854f01410d2d9d3a4">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a6eef6225eba66a86dd32c3f3b79845f7">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#ad1ba32ad7dae0c05a4012ada78077505">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a192581feb2dbcfc9c56692e72e91e9a8">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a7fa856e67a31c86538db7c289a6870e3">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a3f468c8b6cc55d675c75d0184bd8e38a">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#ac6fd43215c8f19082402387359330071">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html#a8fe96aaacf6a2d0780887623a6f2b15a">operator=</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html#aaa92f0fe77bca0af86a3a0ddd77bc96b">operator=</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#af8a93a4c8fb0b78fa6578e7dc95f5751">signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil >::operator=</a>(const signal7 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#ac06938f5cb6ff60a1bd5eaa32c990eea">signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil >::operator=</a>(signal7 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a59c9c9fee7a98528839df592241351a9">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html#ac3cad4e400bacfc4a539cb7a31cd0e01">signal</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html#a9b9928bf9b40cae47599be1f4f7f85dc">signal</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html#a5595334118f67137ded1af1720743da8">signal</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#ab6d54db53a164fb459fcb342d4b45ff0">signal7</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a12d6e064d0a5c2a8c09d60a64184a823">signal7</a>(const signal7 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a5a5893dd4f97d77b7945819f5ada2aee">signal7</a>(signal7 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a68153d9079b4881352113079cd6216f7">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal7.html#a42509108239296e424844df2cd330aca">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::accumulated< T_accumulator >" name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::accumulated< T_accumulator >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::signal5 template." alt="" coords="11,259,241,329"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal5.html" title=" " alt="" coords="5,155,247,211"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="59,80,193,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="68,5,184,32"/>
+</map>
--- /dev/null
+b8f32e3f78b5eef1cf81c0e7ba01c894
\ No newline at end of file
--- /dev/null
+<map id="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::accumulated< T_accumulator >" name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::accumulated< T_accumulator >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::signal# templates." alt="" coords="588,5,789,91"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal7.html" title=" " alt="" coords="351,13,540,83"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="169,35,303,61"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="5,35,121,61"/>
+</map>
--- /dev/null
+6219882fd8423789ffdb2ca00b8535ee
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::accumulated< T_accumulator > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::accumulated< T_accumulator ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html#a3daa5943f5b629a17a547b75743b8829">accumulated</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html#afe1cea16b0f0296ff874a2793cc51b53">accumulated</a>(const accumulated & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a66c302607cf4fb74f5d3352f9c394c9b">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a1754aa5a8959da0bb55e42864a8365af">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#ac88a9c4e9bab5ad04c66d3f5d3978f0f">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#aff490e7f75a83aa2f324a859f9071a79">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a2e8b355902f0646fb34b52b495123167">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#acdd2683223e4701f58350152f32f4488">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a1acee11287974cdac1bc63c856e5331d">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a97ae4180e80ac60b564fec58d1732317">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#affec011fd6e9605f10e50fdd4db424d8">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#ad7a4ab249b17bffccbfe441aa1420dd9">operator=</a>(const signal6 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a012b9abce888e420e1b5b3f29aa98900">operator=</a>(signal6 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a79b741b3f0def8f52fc185ad50b60673">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#af7f529bbd9cf26d468ed18426b9b51ea">signal6</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a0244dde296bd892c590c86ced5281e3b">signal6</a>(const signal6 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#ab717ce413bda79e1de41944d0675a8ca">signal6</a>(signal6 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#a0e4fea9bd1ed35f9d60bbc26c4fae007">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal6.html#af44115a7bfa4586fc5312259a1df9567">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal6.html#ac66109f683ae86898ae10109a80b28a4">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::accumulated< T_accumulator >" name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::accumulated< T_accumulator >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::signal6 template." alt="" coords="577,5,828,76"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal6.html" title=" " alt="" coords="351,5,529,76"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="169,27,303,54"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="5,27,121,54"/>
+</map>
--- /dev/null
+201138ccc7bef847375b3e70d78904fd
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::accumulated< T_accumulator > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_b25fa393130cf385c37b5aed10543944.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::accumulated< T_accumulator > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal6.html" title="Signal declaration.">sigc::signal6</a> template.
+ <a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::accumulated< T_accumulator >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_cec71397b9bd9582728f0b963f11545d.png" border="0" usemap="#asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" id="asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::signal6 template." alt="" coords="577,5,828,76"/>
+<area shape="rect" href="classsigc_1_1signal6.html" title=" " alt="" coords="351,5,529,76"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="169,27,303,54"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="5,27,121,54"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a3daa5943f5b629a17a547b75743b8829"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html#a3daa5943f5b629a17a547b75743b8829">accumulated</a> ()</td></tr>
+<tr class="separator:a3daa5943f5b629a17a547b75743b8829"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afe1cea16b0f0296ff874a2793cc51b53"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html#afe1cea16b0f0296ff874a2793cc51b53">accumulated</a> (const accumulated & src)</td></tr>
+<tr class="separator:afe1cea16b0f0296ff874a2793cc51b53"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal6"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal6')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td></tr>
+<tr class="memitem:af7f529bbd9cf26d468ed18426b9b51ea inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#af7f529bbd9cf26d468ed18426b9b51ea">signal6</a> ()</td></tr>
+<tr class="separator:af7f529bbd9cf26d468ed18426b9b51ea inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0244dde296bd892c590c86ced5281e3b inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a0244dde296bd892c590c86ced5281e3b">signal6</a> (const <a class="el" href="classsigc_1_1signal6.html">signal6</a> & src)</td></tr>
+<tr class="separator:a0244dde296bd892c590c86ced5281e3b inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab717ce413bda79e1de41944d0675a8ca inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#ab717ce413bda79e1de41944d0675a8ca">signal6</a> (<a class="el" href="classsigc_1_1signal6.html">signal6</a> && src)</td></tr>
+<tr class="separator:ab717ce413bda79e1de41944d0675a8ca inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a66c302607cf4fb74f5d3352f9c394c9b inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a1acee11287974cdac1bc63c856e5331d">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a66c302607cf4fb74f5d3352f9c394c9b">connect</a> (const <a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:a66c302607cf4fb74f5d3352f9c394c9b inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal6.html#a66c302607cf4fb74f5d3352f9c394c9b">More...</a><br /></td></tr>
+<tr class="separator:a66c302607cf4fb74f5d3352f9c394c9b inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1754aa5a8959da0bb55e42864a8365af inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a1acee11287974cdac1bc63c856e5331d">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a1754aa5a8959da0bb55e42864a8365af">connect</a> (<a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:a1754aa5a8959da0bb55e42864a8365af inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal6.html#a1754aa5a8959da0bb55e42864a8365af">More...</a><br /></td></tr>
+<tr class="separator:a1754aa5a8959da0bb55e42864a8365af inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a6361a9230323e7c7e86e2c9e6c8fe21b inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:a6361a9230323e7c7e86e2c9e6c8fe21b inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b">More...</a><br /></td></tr>
+<tr class="separator:a6361a9230323e7c7e86e2c9e6c8fe21b inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2e8b355902f0646fb34b52b495123167 inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a2e8b355902f0646fb34b52b495123167">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:a2e8b355902f0646fb34b52b495123167 inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal6.html#a2e8b355902f0646fb34b52b495123167">More...</a><br /></td></tr>
+<tr class="separator:a2e8b355902f0646fb34b52b495123167 inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a97ae4180e80ac60b564fec58d1732317 inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html">bound_const_mem_functor6</a>< <a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a>, <a class="el" href="classsigc_1_1signal6.html">signal6</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a97ae4180e80ac60b564fec58d1732317">make_slot</a> () const</td></tr>
+<tr class="memdesc:a97ae4180e80ac60b564fec58d1732317 inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal6.html#a97ae4180e80ac60b564fec58d1732317">More...</a><br /></td></tr>
+<tr class="separator:a97ae4180e80ac60b564fec58d1732317 inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:affec011fd6e9605f10e50fdd4db424d8 inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#affec011fd6e9605f10e50fdd4db424d8">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:affec011fd6e9605f10e50fdd4db424d8 inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal6.html#affec011fd6e9605f10e50fdd4db424d8">More...</a><br /></td></tr>
+<tr class="separator:affec011fd6e9605f10e50fdd4db424d8 inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad7a4ab249b17bffccbfe441aa1420dd9 inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html">signal6</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#ad7a4ab249b17bffccbfe441aa1420dd9">operator=</a> (const <a class="el" href="classsigc_1_1signal6.html">signal6</a> & src)</td></tr>
+<tr class="separator:ad7a4ab249b17bffccbfe441aa1420dd9 inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a012b9abce888e420e1b5b3f29aa98900 inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html">signal6</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a012b9abce888e420e1b5b3f29aa98900">operator=</a> (<a class="el" href="classsigc_1_1signal6.html">signal6</a> && src)</td></tr>
+<tr class="separator:a012b9abce888e420e1b5b3f29aa98900 inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af44115a7bfa4586fc5312259a1df9567 inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal6.html#a0e4fea9bd1ed35f9d60bbc26c4fae007">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#af44115a7bfa4586fc5312259a1df9567">slots</a> ()</td></tr>
+<tr class="memdesc:af44115a7bfa4586fc5312259a1df9567 inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal6.html#af44115a7bfa4586fc5312259a1df9567">More...</a><br /></td></tr>
+<tr class="separator:af44115a7bfa4586fc5312259a1df9567 inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac66109f683ae86898ae10109a80b28a4 inherit pub_methods_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal6.html#a0e4fea9bd1ed35f9d60bbc26c4fae007">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#ac66109f683ae86898ae10109a80b28a4">slots</a> () const</td></tr>
+<tr class="memdesc:ac66109f683ae86898ae10109a80b28a4 inherit pub_methods_classsigc_1_1signal6"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal6.html#ac66109f683ae86898ae10109a80b28a4">More...</a><br /></td></tr>
+<tr class="separator:ac66109f683ae86898ae10109a80b28a4 inherit pub_methods_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal6"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal6')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td></tr>
+<tr class="memitem:ac88a9c4e9bab5ad04c66d3f5d3978f0f inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#ac88a9c4e9bab5ad04c66d3f5d3978f0f">const_iterator</a></td></tr>
+<tr class="separator:ac88a9c4e9bab5ad04c66d3f5d3978f0f inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aff490e7f75a83aa2f324a859f9071a79 inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#aff490e7f75a83aa2f324a859f9071a79">const_reverse_iterator</a></td></tr>
+<tr class="separator:aff490e7f75a83aa2f324a859f9071a79 inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acdd2683223e4701f58350152f32f4488 inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#acdd2683223e4701f58350152f32f4488">emitter_type</a></td></tr>
+<tr class="separator:acdd2683223e4701f58350152f32f4488 inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1acee11287974cdac1bc63c856e5331d inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a1acee11287974cdac1bc63c856e5331d">iterator</a></td></tr>
+<tr class="separator:a1acee11287974cdac1bc63c856e5331d inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a56f1acca230e676dae665d41a10acc8f inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">result_type</a></td></tr>
+<tr class="separator:a56f1acca230e676dae665d41a10acc8f inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a79b741b3f0def8f52fc185ad50b60673 inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a79b741b3f0def8f52fc185ad50b60673">reverse_iterator</a></td></tr>
+<tr class="separator:a79b741b3f0def8f52fc185ad50b60673 inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0e4fea9bd1ed35f9d60bbc26c4fae007 inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#a0e4fea9bd1ed35f9d60bbc26c4fae007">slot_list_type</a></td></tr>
+<tr class="separator:a0e4fea9bd1ed35f9d60bbc26c4fae007 inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac62cdf4db7dcd5e30975e51e978f03db inherit pub_types_classsigc_1_1signal6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">slot_type</a></td></tr>
+<tr class="separator:ac62cdf4db7dcd5e30975e51e978f03db inherit pub_types_classsigc_1_1signal6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6><br />
+template <class T_accumulator><br />
+class sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::accumulated< T_accumulator ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal6.html" title="Signal declaration.">sigc::signal6</a> template. </p>
+<p>Like <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> but the additional template parameter <em>T_accumulator</em> defines the accumulator type that should be used. </p>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a3daa5943f5b629a17a547b75743b8829"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3daa5943f5b629a17a547b75743b8829">◆ </a></span>accumulated() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="afe1cea16b0f0296ff874a2793cc51b53"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#afe1cea16b0f0296ff874a2793cc51b53">◆ </a></span>accumulated() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramtype">const accumulated & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>" name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>">
+<area shape="rect" id="node1" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="17,259,207,315"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal6.html" title=" " alt="" coords="5,155,219,211"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="45,80,179,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="54,5,170,32"/>
+</map>
--- /dev/null
+a729bcbb0c84409edf2456796b4cf85d
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::accumulated< T_accumulator > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_2dcd48aa9344cd20f26fc637ee88a87b.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::accumulated< T_accumulator > Class Template Reference<div class="ingroups"><a class="el" href="group__signal.html">Signals</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates.
+ <a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::accumulated< T_accumulator >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_9258c1efa2d00a7da0d81978110ea314.png" border="0" usemap="#asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" id="asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::signal# templates." alt="" coords="588,5,789,91"/>
+<area shape="rect" href="classsigc_1_1signal7.html" title=" " alt="" coords="351,13,540,83"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="169,35,303,61"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="5,35,121,61"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a33552c46e4db86b98bea128fd32d2c08"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html#a33552c46e4db86b98bea128fd32d2c08">accumulated</a> ()</td></tr>
+<tr class="separator:a33552c46e4db86b98bea128fd32d2c08"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afc104f4e3d7a445cf4f7989c52f1d93c"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html#afc104f4e3d7a445cf4f7989c52f1d93c">accumulated</a> (const accumulated & src)</td></tr>
+<tr class="separator:afc104f4e3d7a445cf4f7989c52f1d93c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal7"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal7')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td></tr>
+<tr class="memitem:ab6d54db53a164fb459fcb342d4b45ff0 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#ab6d54db53a164fb459fcb342d4b45ff0">signal7</a> ()</td></tr>
+<tr class="separator:ab6d54db53a164fb459fcb342d4b45ff0 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a12d6e064d0a5c2a8c09d60a64184a823 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a12d6e064d0a5c2a8c09d60a64184a823">signal7</a> (const <a class="el" href="classsigc_1_1signal7.html">signal7</a> & src)</td></tr>
+<tr class="separator:a12d6e064d0a5c2a8c09d60a64184a823 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5a5893dd4f97d77b7945819f5ada2aee inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a5a5893dd4f97d77b7945819f5ada2aee">signal7</a> (<a class="el" href="classsigc_1_1signal7.html">signal7</a> && src)</td></tr>
+<tr class="separator:a5a5893dd4f97d77b7945819f5ada2aee inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adc55ac9b0f935fd87a67904022e03cb2 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">connect</a> (const <a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:adc55ac9b0f935fd87a67904022e03cb2 inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">More...</a><br /></td></tr>
+<tr class="separator:adc55ac9b0f935fd87a67904022e03cb2 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5aed4bdb8d85c3d854f01410d2d9d3a4 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a5aed4bdb8d85c3d854f01410d2d9d3a4">connect</a> (<a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:a5aed4bdb8d85c3d854f01410d2d9d3a4 inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal7.html#a5aed4bdb8d85c3d854f01410d2d9d3a4">More...</a><br /></td></tr>
+<tr class="separator:a5aed4bdb8d85c3d854f01410d2d9d3a4 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aead3b0e97ed0bd95f870b1956bff83c2 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:aead3b0e97ed0bd95f870b1956bff83c2 inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2">More...</a><br /></td></tr>
+<tr class="separator:aead3b0e97ed0bd95f870b1956bff83c2 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a192581feb2dbcfc9c56692e72e91e9a8 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a192581feb2dbcfc9c56692e72e91e9a8">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:a192581feb2dbcfc9c56692e72e91e9a8 inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal7.html#a192581feb2dbcfc9c56692e72e91e9a8">More...</a><br /></td></tr>
+<tr class="separator:a192581feb2dbcfc9c56692e72e91e9a8 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3f468c8b6cc55d675c75d0184bd8e38a inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html">bound_const_mem_functor7</a>< <a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a>, <a class="el" href="classsigc_1_1signal7.html">signal7</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a3f468c8b6cc55d675c75d0184bd8e38a">make_slot</a> () const</td></tr>
+<tr class="memdesc:a3f468c8b6cc55d675c75d0184bd8e38a inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal7.html#a3f468c8b6cc55d675c75d0184bd8e38a">More...</a><br /></td></tr>
+<tr class="separator:a3f468c8b6cc55d675c75d0184bd8e38a inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac6fd43215c8f19082402387359330071 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#ac6fd43215c8f19082402387359330071">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:ac6fd43215c8f19082402387359330071 inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal7.html#ac6fd43215c8f19082402387359330071">More...</a><br /></td></tr>
+<tr class="separator:ac6fd43215c8f19082402387359330071 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af8a93a4c8fb0b78fa6578e7dc95f5751 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html">signal7</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#af8a93a4c8fb0b78fa6578e7dc95f5751">operator=</a> (const <a class="el" href="classsigc_1_1signal7.html">signal7</a> & src)</td></tr>
+<tr class="separator:af8a93a4c8fb0b78fa6578e7dc95f5751 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac06938f5cb6ff60a1bd5eaa32c990eea inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html">signal7</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#ac06938f5cb6ff60a1bd5eaa32c990eea">operator=</a> (<a class="el" href="classsigc_1_1signal7.html">signal7</a> && src)</td></tr>
+<tr class="separator:ac06938f5cb6ff60a1bd5eaa32c990eea inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a68153d9079b4881352113079cd6216f7 inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a68153d9079b4881352113079cd6216f7">slots</a> ()</td></tr>
+<tr class="memdesc:a68153d9079b4881352113079cd6216f7 inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal7.html#a68153d9079b4881352113079cd6216f7">More...</a><br /></td></tr>
+<tr class="separator:a68153d9079b4881352113079cd6216f7 inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a42509108239296e424844df2cd330aca inherit pub_methods_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a42509108239296e424844df2cd330aca">slots</a> () const</td></tr>
+<tr class="memdesc:a42509108239296e424844df2cd330aca inherit pub_methods_classsigc_1_1signal7"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal7.html#a42509108239296e424844df2cd330aca">More...</a><br /></td></tr>
+<tr class="separator:a42509108239296e424844df2cd330aca inherit pub_methods_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal7"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal7')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td></tr>
+<tr class="memitem:a6eef6225eba66a86dd32c3f3b79845f7 inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a6eef6225eba66a86dd32c3f3b79845f7">const_iterator</a></td></tr>
+<tr class="separator:a6eef6225eba66a86dd32c3f3b79845f7 inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1ba32ad7dae0c05a4012ada78077505 inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#ad1ba32ad7dae0c05a4012ada78077505">const_reverse_iterator</a></td></tr>
+<tr class="separator:ad1ba32ad7dae0c05a4012ada78077505 inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7fa856e67a31c86538db7c289a6870e3 inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a7fa856e67a31c86538db7c289a6870e3">emitter_type</a></td></tr>
+<tr class="separator:a7fa856e67a31c86538db7c289a6870e3 inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abc62e52cc684f917577a2fe3cd914d4a inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a">iterator</a></td></tr>
+<tr class="separator:abc62e52cc684f917577a2fe3cd914d4a inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5a75d73a254cf91a0f3ad1cd3545e29f inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a></td></tr>
+<tr class="separator:a5a75d73a254cf91a0f3ad1cd3545e29f inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a59c9c9fee7a98528839df592241351a9 inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a59c9c9fee7a98528839df592241351a9">reverse_iterator</a></td></tr>
+<tr class="separator:a59c9c9fee7a98528839df592241351a9 inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a79686c2174ab01dc23394953955ff003 inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003">slot_list_type</a></td></tr>
+<tr class="separator:a79686c2174ab01dc23394953955ff003 inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a72ee8c51eea3d1ba99eb9b512dfccd81 inherit pub_types_classsigc_1_1signal7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">slot_type</a></td></tr>
+<tr class="separator:a72ee8c51eea3d1ba99eb9b512dfccd81 inherit pub_types_classsigc_1_1signal7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7><br />
+template <class T_accumulator><br />
+class sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::accumulated< T_accumulator ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates. </p>
+<p>Like <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> but the additional template parameter <em>T_accumulator</em> defines the accumulator type that should be used.</p>
+<p>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' <a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01554.html#ga1383aaa1e6ca24ab907dea89ea4c3118">operator*()</a> executes the slot. The return value is buffered, so that in an expression like</p><div class="fragment"><div class="line">a = (*i) * (*i); </div>
+</div><!-- fragment --><p> the slot is executed only once. The accumulator must define its return value as <code>result_type</code>.</p>
+<dl class="section user"><dt>Example 1:</dt><dd>This accumulator calculates the arithmetic mean value: <div class="fragment"><div class="line"><span class="keyword">struct </span>arithmetic_mean_accumulator</div>
+<div class="line">{</div>
+<div class="line"> <span class="keyword">typedef</span> <span class="keywordtype">double</span> <a class="code" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a>;</div>
+<div class="line"> <span class="keyword">template</span><<span class="keyword">typename</span> T_iterator></div>
+<div class="line"> <a class="code" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> <a class="code" href="classsigc_1_1signal7.html#ac6fd43215c8f19082402387359330071">operator()</a>(T_iterator first, T_iterator last)<span class="keyword"> const</span></div>
+<div class="line"><span class="keyword"> </span>{</div>
+<div class="line"> <a class="code" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> value_ = 0;</div>
+<div class="line"> <span class="keywordtype">int</span> n_ = 0;</div>
+<div class="line"> <span class="keywordflow">for</span> (; first != last; ++first, ++n_)</div>
+<div class="line"> value_ += *first;</div>
+<div class="line"> <span class="keywordflow">return</span> value_ / n_;</div>
+<div class="line"> }</div>
+<div class="line">};</div>
+<div class="ttc" id="aclasssigc_1_1signal7_html_a5a75d73a254cf91a0f3ad1cd3545e29f"><div class="ttname"><a href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::result_type</a></div><div class="ttdeci">emitter_type::result_type result_type</div><div class="ttdef"><b>Definition:</b> signal.h:3842</div></div>
+<div class="ttc" id="aclasssigc_1_1signal7_html_ac6fd43215c8f19082402387359330071"><div class="ttname"><a href="classsigc_1_1signal7.html#ac6fd43215c8f19082402387359330071">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::operator()</a></div><div class="ttdeci">result_type operator()(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</div><div class="ttdoc">Triggers the emission of the signal (see emit()).</div><div class="ttdef"><b>Definition:</b> signal.h:3914</div></div>
+</div><!-- fragment --></dd></dl>
+<dl class="section user"><dt>Example 2:</dt><dd>This accumulator stops signal emission when a slot returns zero: <div class="fragment"><div class="line"><span class="keyword">struct </span>interruptable_accumulator</div>
+<div class="line">{</div>
+<div class="line"> <span class="keyword">typedef</span> <span class="keywordtype">bool</span> <a class="code" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a>;</div>
+<div class="line"> <span class="keyword">template</span><<span class="keyword">typename</span> T_iterator></div>
+<div class="line"> <a class="code" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">result_type</a> <a class="code" href="classsigc_1_1signal7.html#ac6fd43215c8f19082402387359330071">operator()</a>(T_iterator first, T_iterator last)<span class="keyword"> const</span></div>
+<div class="line"><span class="keyword"> </span>{</div>
+<div class="line"> <span class="keywordflow">for</span> (; first != last; ++first, ++n_)</div>
+<div class="line"> <span class="keywordflow">if</span> (!*first) <span class="keywordflow">return</span> <span class="keyword">false</span>;</div>
+<div class="line"> <span class="keywordflow">return</span> <span class="keyword">true</span>;</div>
+<div class="line"> }</div>
+<div class="line">};</div>
+</div><!-- fragment --> </dd></dl>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a33552c46e4db86b98bea128fd32d2c08"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a33552c46e4db86b98bea128fd32d2c08">◆ </a></span>accumulated() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="afc104f4e3d7a445cf4f7989c52f1d93c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#afc104f4e3d7a445cf4f7989c52f1d93c">◆ </a></span>accumulated() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramtype">const accumulated & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>" name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>">
+<area shape="rect" id="node1" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="577,5,756,76"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal7.html" title=" " alt="" coords="351,5,529,76"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="169,27,303,54"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="5,27,121,54"/>
+</map>
--- /dev/null
+85f8161965110d598224372d62d7aec8
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)> Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a5fdb6df3cf74f5c96fb6319eef4d0a39">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a5c8d2d9c91a134650a52631d49ecdaac">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a3d2626edc726047c04c8fe5b9824b958">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a555ce030884fdf2bde788b75db01bedf">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a0aaf27875cdb8a0ae381372d98871ae1">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#acf3d1e6d6487c0ecc13ed3eab949eec7">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a31e8354263a3097bba9c63b8494143f0">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#aebcf1389e689b8d43ff739df118482bc">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a8523a4d47c3a6469fcc50da9977afdb8">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html#a838a70902714d4cb065ea1bf22e0f376">operator=</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html#abeda698e53b2b9b3bd9e5aa91f02abfd">operator=</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a05908db9c09a9c513529cd8b2106f913">signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil >::operator=</a>(const signal4 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#ab21da01af7c724bf0cf9df35ee9a70c1">signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil >::operator=</a>(signal4 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a1395da7d3283b0166af135193a4047c8">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html#a1569f4348e140681f696a49028309042">signal</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html#a435444e5772da8ddb74edb7f901f3ae6">signal</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html#a8d26e7db0ca474d71736c778e0264f4c">signal</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a2d469f516a9edac2b20d7f6cf46e821a">signal4</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a2d29b39c12c6c014ed7166190e9c8e22">signal4</a>(const signal4 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a2197974bac2b5e8e7b1c417580686e9e">signal4</a>(signal4 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a0ad0f56a43825c6d77d36dd2f06ef828">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#ae490f1a6802c40a4c3b12e1580520c88">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a35f2cebe3804d3e04d3253b7cc8d2a72">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)> Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#nested-classes">Classes</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)> Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This specialization allow use of the sigc::signal<R(Args...)> syntax,.
+ <a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4__inherit__graph.png" border="0" usemap="#asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_inherit__map" id="asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_inherit__map">
+<area shape="rect" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="5,259,184,315"/>
+<area shape="rect" href="classsigc_1_1signal4.html" title=" " alt="" coords="5,155,184,211"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="28,80,161,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="37,5,153,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Classes</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html">accumulated</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal4.html" title="Signal declaration.">sigc::signal4</a> template. <a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a1569f4348e140681f696a49028309042"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html#a1569f4348e140681f696a49028309042">signal</a> ()</td></tr>
+<tr class="separator:a1569f4348e140681f696a49028309042"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a435444e5772da8ddb74edb7f901f3ae6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html#a435444e5772da8ddb74edb7f901f3ae6">signal</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:a435444e5772da8ddb74edb7f901f3ae6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8d26e7db0ca474d71736c778e0264f4c"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html#a8d26e7db0ca474d71736c778e0264f4c">signal</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:a8d26e7db0ca474d71736c778e0264f4c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a838a70902714d4cb065ea1bf22e0f376"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html#a838a70902714d4cb065ea1bf22e0f376">operator=</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:a838a70902714d4cb065ea1bf22e0f376"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abeda698e53b2b9b3bd9e5aa91f02abfd"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html#abeda698e53b2b9b3bd9e5aa91f02abfd">operator=</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:abeda698e53b2b9b3bd9e5aa91f02abfd"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal4"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal4')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td></tr>
+<tr class="memitem:a2d469f516a9edac2b20d7f6cf46e821a inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a2d469f516a9edac2b20d7f6cf46e821a">signal4</a> ()</td></tr>
+<tr class="separator:a2d469f516a9edac2b20d7f6cf46e821a inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2d29b39c12c6c014ed7166190e9c8e22 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a2d29b39c12c6c014ed7166190e9c8e22">signal4</a> (const <a class="el" href="classsigc_1_1signal4.html">signal4</a> & src)</td></tr>
+<tr class="separator:a2d29b39c12c6c014ed7166190e9c8e22 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2197974bac2b5e8e7b1c417580686e9e inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a2197974bac2b5e8e7b1c417580686e9e">signal4</a> (<a class="el" href="classsigc_1_1signal4.html">signal4</a> && src)</td></tr>
+<tr class="separator:a2197974bac2b5e8e7b1c417580686e9e inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5fdb6df3cf74f5c96fb6319eef4d0a39 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#a31e8354263a3097bba9c63b8494143f0">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a5fdb6df3cf74f5c96fb6319eef4d0a39">connect</a> (const <a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:a5fdb6df3cf74f5c96fb6319eef4d0a39 inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal4.html#a5fdb6df3cf74f5c96fb6319eef4d0a39">More...</a><br /></td></tr>
+<tr class="separator:a5fdb6df3cf74f5c96fb6319eef4d0a39 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5c8d2d9c91a134650a52631d49ecdaac inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#a31e8354263a3097bba9c63b8494143f0">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a5c8d2d9c91a134650a52631d49ecdaac">connect</a> (<a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:a5c8d2d9c91a134650a52631d49ecdaac inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal4.html#a5c8d2d9c91a134650a52631d49ecdaac">More...</a><br /></td></tr>
+<tr class="separator:a5c8d2d9c91a134650a52631d49ecdaac inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7774ba75b5e2391a6fe2841f8b3b0ef inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:aa7774ba75b5e2391a6fe2841f8b3b0ef inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef">More...</a><br /></td></tr>
+<tr class="separator:aa7774ba75b5e2391a6fe2841f8b3b0ef inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0aaf27875cdb8a0ae381372d98871ae1 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a0aaf27875cdb8a0ae381372d98871ae1">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:a0aaf27875cdb8a0ae381372d98871ae1 inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal4.html#a0aaf27875cdb8a0ae381372d98871ae1">More...</a><br /></td></tr>
+<tr class="separator:a0aaf27875cdb8a0ae381372d98871ae1 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebcf1389e689b8d43ff739df118482bc inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html">bound_const_mem_functor4</a>< <a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a>, <a class="el" href="classsigc_1_1signal4.html">signal4</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#aebcf1389e689b8d43ff739df118482bc">make_slot</a> () const</td></tr>
+<tr class="memdesc:aebcf1389e689b8d43ff739df118482bc inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal4.html#aebcf1389e689b8d43ff739df118482bc">More...</a><br /></td></tr>
+<tr class="separator:aebcf1389e689b8d43ff739df118482bc inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8523a4d47c3a6469fcc50da9977afdb8 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a8523a4d47c3a6469fcc50da9977afdb8">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:a8523a4d47c3a6469fcc50da9977afdb8 inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal4.html#a8523a4d47c3a6469fcc50da9977afdb8">More...</a><br /></td></tr>
+<tr class="separator:a8523a4d47c3a6469fcc50da9977afdb8 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a05908db9c09a9c513529cd8b2106f913 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html">signal4</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a05908db9c09a9c513529cd8b2106f913">operator=</a> (const <a class="el" href="classsigc_1_1signal4.html">signal4</a> & src)</td></tr>
+<tr class="separator:a05908db9c09a9c513529cd8b2106f913 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab21da01af7c724bf0cf9df35ee9a70c1 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html">signal4</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#ab21da01af7c724bf0cf9df35ee9a70c1">operator=</a> (<a class="el" href="classsigc_1_1signal4.html">signal4</a> && src)</td></tr>
+<tr class="separator:ab21da01af7c724bf0cf9df35ee9a70c1 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae490f1a6802c40a4c3b12e1580520c88 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#a0ad0f56a43825c6d77d36dd2f06ef828">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#ae490f1a6802c40a4c3b12e1580520c88">slots</a> ()</td></tr>
+<tr class="memdesc:ae490f1a6802c40a4c3b12e1580520c88 inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal4.html#ae490f1a6802c40a4c3b12e1580520c88">More...</a><br /></td></tr>
+<tr class="separator:ae490f1a6802c40a4c3b12e1580520c88 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a35f2cebe3804d3e04d3253b7cc8d2a72 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal4.html#a0ad0f56a43825c6d77d36dd2f06ef828">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a35f2cebe3804d3e04d3253b7cc8d2a72">slots</a> () const</td></tr>
+<tr class="memdesc:a35f2cebe3804d3e04d3253b7cc8d2a72 inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal4.html#a35f2cebe3804d3e04d3253b7cc8d2a72">More...</a><br /></td></tr>
+<tr class="separator:a35f2cebe3804d3e04d3253b7cc8d2a72 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal4"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal4')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td></tr>
+<tr class="memitem:a3d2626edc726047c04c8fe5b9824b958 inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a3d2626edc726047c04c8fe5b9824b958">const_iterator</a></td></tr>
+<tr class="separator:a3d2626edc726047c04c8fe5b9824b958 inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a555ce030884fdf2bde788b75db01bedf inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a555ce030884fdf2bde788b75db01bedf">const_reverse_iterator</a></td></tr>
+<tr class="separator:a555ce030884fdf2bde788b75db01bedf inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acf3d1e6d6487c0ecc13ed3eab949eec7 inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, <a class="el" href="structsigc_1_1nil.html">nil</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#acf3d1e6d6487c0ecc13ed3eab949eec7">emitter_type</a></td></tr>
+<tr class="separator:acf3d1e6d6487c0ecc13ed3eab949eec7 inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a31e8354263a3097bba9c63b8494143f0 inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a31e8354263a3097bba9c63b8494143f0">iterator</a></td></tr>
+<tr class="separator:a31e8354263a3097bba9c63b8494143f0 inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af32418ba14001a63d28af08abb7407f0 inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a></td></tr>
+<tr class="separator:af32418ba14001a63d28af08abb7407f0 inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1395da7d3283b0166af135193a4047c8 inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a1395da7d3283b0166af135193a4047c8">reverse_iterator</a></td></tr>
+<tr class="separator:a1395da7d3283b0166af135193a4047c8 inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0ad0f56a43825c6d77d36dd2f06ef828 inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a0ad0f56a43825c6d77d36dd2f06ef828">slot_list_type</a></td></tr>
+<tr class="separator:a0ad0f56a43825c6d77d36dd2f06ef828 inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa93452fe80399184444d094786be851c inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a></td></tr>
+<tr class="separator:aa93452fe80399184444d094786be851c inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4><br />
+class sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)></h3>
+
+<p>This specialization allow use of the sigc::signal<R(Args...)> syntax,. </p>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a1569f4348e140681f696a49028309042"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1569f4348e140681f696a49028309042">◆ </a></span>signal() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a435444e5772da8ddb74edb7f901f3ae6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a435444e5772da8ddb74edb7f901f3ae6">◆ </a></span>signal() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4)> & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a8d26e7db0ca474d71736c778e0264f4c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8d26e7db0ca474d71736c778e0264f4c">◆ </a></span>signal() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4)> && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a838a70902714d4cb065ea1bf22e0f376"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a838a70902714d4cb065ea1bf22e0f376">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4)> & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="abeda698e53b2b9b3bd9e5aa91f02abfd"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abeda698e53b2b9b3bd9e5aa91f02abfd">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4)> && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::accumulated< T_accumulator > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::accumulated< T_accumulator ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html#acd7fd012dcc073e9a6770af949517040">accumulated</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html#a3197013a55f3afc0fb9451b033c3fe47">accumulated</a>(const accumulated & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a5fdb6df3cf74f5c96fb6319eef4d0a39">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a5c8d2d9c91a134650a52631d49ecdaac">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a3d2626edc726047c04c8fe5b9824b958">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a555ce030884fdf2bde788b75db01bedf">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a0aaf27875cdb8a0ae381372d98871ae1">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#acf3d1e6d6487c0ecc13ed3eab949eec7">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a31e8354263a3097bba9c63b8494143f0">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#aebcf1389e689b8d43ff739df118482bc">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a8523a4d47c3a6469fcc50da9977afdb8">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a05908db9c09a9c513529cd8b2106f913">operator=</a>(const signal4 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#ab21da01af7c724bf0cf9df35ee9a70c1">operator=</a>(signal4 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a1395da7d3283b0166af135193a4047c8">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a2d469f516a9edac2b20d7f6cf46e821a">signal4</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a2d29b39c12c6c014ed7166190e9c8e22">signal4</a>(const signal4 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a2197974bac2b5e8e7b1c417580686e9e">signal4</a>(signal4 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a0ad0f56a43825c6d77d36dd2f06ef828">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal4.html#ae490f1a6802c40a4c3b12e1580520c88">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal4.html#a35f2cebe3804d3e04d3253b7cc8d2a72">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::accumulated< T_accumulator > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::accumulated< T_accumulator > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal4.html" title="Signal declaration.">sigc::signal4</a> template.
+ <a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::accumulated< T_accumulator >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated__inherit__graph.png" border="0" usemap="#asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" id="asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::signal4 template." alt="" coords="5,259,195,329"/>
+<area shape="rect" href="classsigc_1_1signal4.html" title=" " alt="" coords="5,155,195,211"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="33,80,167,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="42,5,158,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:acd7fd012dcc073e9a6770af949517040"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html#acd7fd012dcc073e9a6770af949517040">accumulated</a> ()</td></tr>
+<tr class="separator:acd7fd012dcc073e9a6770af949517040"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3197013a55f3afc0fb9451b033c3fe47"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html#a3197013a55f3afc0fb9451b033c3fe47">accumulated</a> (const accumulated & src)</td></tr>
+<tr class="separator:a3197013a55f3afc0fb9451b033c3fe47"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal4"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal4')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td></tr>
+<tr class="memitem:a2d469f516a9edac2b20d7f6cf46e821a inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a2d469f516a9edac2b20d7f6cf46e821a">signal4</a> ()</td></tr>
+<tr class="separator:a2d469f516a9edac2b20d7f6cf46e821a inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2d29b39c12c6c014ed7166190e9c8e22 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a2d29b39c12c6c014ed7166190e9c8e22">signal4</a> (const <a class="el" href="classsigc_1_1signal4.html">signal4</a> & src)</td></tr>
+<tr class="separator:a2d29b39c12c6c014ed7166190e9c8e22 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2197974bac2b5e8e7b1c417580686e9e inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a2197974bac2b5e8e7b1c417580686e9e">signal4</a> (<a class="el" href="classsigc_1_1signal4.html">signal4</a> && src)</td></tr>
+<tr class="separator:a2197974bac2b5e8e7b1c417580686e9e inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5fdb6df3cf74f5c96fb6319eef4d0a39 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#a31e8354263a3097bba9c63b8494143f0">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a5fdb6df3cf74f5c96fb6319eef4d0a39">connect</a> (const <a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:a5fdb6df3cf74f5c96fb6319eef4d0a39 inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal4.html#a5fdb6df3cf74f5c96fb6319eef4d0a39">More...</a><br /></td></tr>
+<tr class="separator:a5fdb6df3cf74f5c96fb6319eef4d0a39 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5c8d2d9c91a134650a52631d49ecdaac inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#a31e8354263a3097bba9c63b8494143f0">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a5c8d2d9c91a134650a52631d49ecdaac">connect</a> (<a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:a5c8d2d9c91a134650a52631d49ecdaac inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal4.html#a5c8d2d9c91a134650a52631d49ecdaac">More...</a><br /></td></tr>
+<tr class="separator:a5c8d2d9c91a134650a52631d49ecdaac inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7774ba75b5e2391a6fe2841f8b3b0ef inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:aa7774ba75b5e2391a6fe2841f8b3b0ef inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef">More...</a><br /></td></tr>
+<tr class="separator:aa7774ba75b5e2391a6fe2841f8b3b0ef inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0aaf27875cdb8a0ae381372d98871ae1 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a0aaf27875cdb8a0ae381372d98871ae1">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:a0aaf27875cdb8a0ae381372d98871ae1 inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal4.html#a0aaf27875cdb8a0ae381372d98871ae1">More...</a><br /></td></tr>
+<tr class="separator:a0aaf27875cdb8a0ae381372d98871ae1 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebcf1389e689b8d43ff739df118482bc inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html">bound_const_mem_functor4</a>< <a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a>, <a class="el" href="classsigc_1_1signal4.html">signal4</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#aebcf1389e689b8d43ff739df118482bc">make_slot</a> () const</td></tr>
+<tr class="memdesc:aebcf1389e689b8d43ff739df118482bc inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal4.html#aebcf1389e689b8d43ff739df118482bc">More...</a><br /></td></tr>
+<tr class="separator:aebcf1389e689b8d43ff739df118482bc inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8523a4d47c3a6469fcc50da9977afdb8 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a8523a4d47c3a6469fcc50da9977afdb8">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:a8523a4d47c3a6469fcc50da9977afdb8 inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal4.html#a8523a4d47c3a6469fcc50da9977afdb8">More...</a><br /></td></tr>
+<tr class="separator:a8523a4d47c3a6469fcc50da9977afdb8 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a05908db9c09a9c513529cd8b2106f913 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html">signal4</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a05908db9c09a9c513529cd8b2106f913">operator=</a> (const <a class="el" href="classsigc_1_1signal4.html">signal4</a> & src)</td></tr>
+<tr class="separator:a05908db9c09a9c513529cd8b2106f913 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab21da01af7c724bf0cf9df35ee9a70c1 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html">signal4</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#ab21da01af7c724bf0cf9df35ee9a70c1">operator=</a> (<a class="el" href="classsigc_1_1signal4.html">signal4</a> && src)</td></tr>
+<tr class="separator:ab21da01af7c724bf0cf9df35ee9a70c1 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae490f1a6802c40a4c3b12e1580520c88 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal4.html#a0ad0f56a43825c6d77d36dd2f06ef828">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#ae490f1a6802c40a4c3b12e1580520c88">slots</a> ()</td></tr>
+<tr class="memdesc:ae490f1a6802c40a4c3b12e1580520c88 inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal4.html#ae490f1a6802c40a4c3b12e1580520c88">More...</a><br /></td></tr>
+<tr class="separator:ae490f1a6802c40a4c3b12e1580520c88 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a35f2cebe3804d3e04d3253b7cc8d2a72 inherit pub_methods_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal4.html#a0ad0f56a43825c6d77d36dd2f06ef828">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a35f2cebe3804d3e04d3253b7cc8d2a72">slots</a> () const</td></tr>
+<tr class="memdesc:a35f2cebe3804d3e04d3253b7cc8d2a72 inherit pub_methods_classsigc_1_1signal4"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal4.html#a35f2cebe3804d3e04d3253b7cc8d2a72">More...</a><br /></td></tr>
+<tr class="separator:a35f2cebe3804d3e04d3253b7cc8d2a72 inherit pub_methods_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal4"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal4')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td></tr>
+<tr class="memitem:a3d2626edc726047c04c8fe5b9824b958 inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a3d2626edc726047c04c8fe5b9824b958">const_iterator</a></td></tr>
+<tr class="separator:a3d2626edc726047c04c8fe5b9824b958 inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a555ce030884fdf2bde788b75db01bedf inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a555ce030884fdf2bde788b75db01bedf">const_reverse_iterator</a></td></tr>
+<tr class="separator:a555ce030884fdf2bde788b75db01bedf inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acf3d1e6d6487c0ecc13ed3eab949eec7 inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#acf3d1e6d6487c0ecc13ed3eab949eec7">emitter_type</a></td></tr>
+<tr class="separator:acf3d1e6d6487c0ecc13ed3eab949eec7 inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a31e8354263a3097bba9c63b8494143f0 inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a31e8354263a3097bba9c63b8494143f0">iterator</a></td></tr>
+<tr class="separator:a31e8354263a3097bba9c63b8494143f0 inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af32418ba14001a63d28af08abb7407f0 inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">result_type</a></td></tr>
+<tr class="separator:af32418ba14001a63d28af08abb7407f0 inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1395da7d3283b0166af135193a4047c8 inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a1395da7d3283b0166af135193a4047c8">reverse_iterator</a></td></tr>
+<tr class="separator:a1395da7d3283b0166af135193a4047c8 inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0ad0f56a43825c6d77d36dd2f06ef828 inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#a0ad0f56a43825c6d77d36dd2f06ef828">slot_list_type</a></td></tr>
+<tr class="separator:a0ad0f56a43825c6d77d36dd2f06ef828 inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa93452fe80399184444d094786be851c inherit pub_types_classsigc_1_1signal4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">slot_type</a></td></tr>
+<tr class="separator:aa93452fe80399184444d094786be851c inherit pub_types_classsigc_1_1signal4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4><br />
+template <class T_accumulator><br />
+class sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::accumulated< T_accumulator ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal4.html" title="Signal declaration.">sigc::signal4</a> template. </p>
+<p>Like <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> but the additional template parameter <em>T_accumulator</em> defines the accumulator type that should be used. </p>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="acd7fd012dcc073e9a6770af949517040"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#acd7fd012dcc073e9a6770af949517040">◆ </a></span>accumulated() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a3197013a55f3afc0fb9451b033c3fe47"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3197013a55f3afc0fb9451b033c3fe47">◆ </a></span>accumulated() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramtype">const accumulated & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::accumulated< T_accumulator >" name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::accumulated< T_accumulator >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::signal4 template." alt="" coords="5,259,195,329"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal4.html" title=" " alt="" coords="5,155,195,211"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="33,80,167,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="42,5,158,32"/>
+</map>
--- /dev/null
+95e8cf94f92838159ab823e4582a8552
\ No newline at end of file
--- /dev/null
+<map id="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>" name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>">
+<area shape="rect" id="node1" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="5,259,184,315"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal4.html" title=" " alt="" coords="5,155,184,211"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="28,80,161,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="37,5,153,32"/>
+</map>
--- /dev/null
+b04a791b10510889c24e5494f3f34421
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3)></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return(T_arg1, T_arg2, T_arg3)> Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3)></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a3eae0b3796b2736be847f33a5124aacd">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#ad71389c6d6ea60e745897579b3344d00">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a60e1ef95f82cd8981d61576d1e3f8e94">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a4ba3eb58c4c5ac2c25f49c48fd0af264">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a97ff4f22c97920a81e3f27aa5d39ba99">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#adf54ec96c5fb78d4c8b7fc032a1937ad">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a8029a48126a2018947a2b6680ddabe6b">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a332be8eb0ee22c11a2e1d140ca1bc2df">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#aa7ae5338d6a883a28c61ff202e43547f">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html#a43ee800d35a162d99893f6a55f5a7c72">operator=</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html#aee5b61e3b98fe989e78f96d2117d74d1">operator=</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a0c398a25051e920bc4338f35b4bf7df6">signal3< T_return, T_arg1, T_arg2, T_arg3, nil >::operator=</a>(const signal3 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#abafd9fe17f2b9b18e25eb0293e9e8bfd">signal3< T_return, T_arg1, T_arg2, T_arg3, nil >::operator=</a>(signal3 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#acc453f0d5fc7f277494b2d6e737f6f68">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html#a27d493742451c292a6c001b9353c08d9">signal</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html#a51bd913df6a849d6dd720e8c19532149">signal</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html#ac22b59e41db40b6cbe6ac4b71d048170">signal</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a52731959f272612fd6abfe8850c5c8cf">signal3</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#afe2c4320927b403b011a2538317e6c70">signal3</a>(const signal3 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#acd69c2a1d993f0b8993f82998f76020d">signal3</a>(signal3 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a3bc0616e7ac933e702a889a2a84e92d4">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#ab9606b708078956a758b81503f956bee">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a742eb282312187bf8ee6992df1114781">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return(T_arg1, T_arg2, T_arg3)> Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3)></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#nested-classes">Classes</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return(T_arg1, T_arg2, T_arg3)> Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This specialization allow use of the sigc::signal<R(Args...)> syntax,.
+ <a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return(T_arg1, T_arg2, T_arg3)>:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4__inherit__graph.png" border="0" usemap="#asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_inherit__map" id="asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_inherit__map">
+<area shape="rect" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="5,259,196,300"/>
+<area shape="rect" href="classsigc_1_1signal3.html" title=" " alt="" coords="11,155,190,211"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="34,80,167,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="43,5,159,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Classes</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html">accumulated</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal3.html" title="Signal declaration.">sigc::signal3</a> template. <a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a27d493742451c292a6c001b9353c08d9"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html#a27d493742451c292a6c001b9353c08d9">signal</a> ()</td></tr>
+<tr class="separator:a27d493742451c292a6c001b9353c08d9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a51bd913df6a849d6dd720e8c19532149"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html#a51bd913df6a849d6dd720e8c19532149">signal</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:a51bd913df6a849d6dd720e8c19532149"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac22b59e41db40b6cbe6ac4b71d048170"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html#ac22b59e41db40b6cbe6ac4b71d048170">signal</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:ac22b59e41db40b6cbe6ac4b71d048170"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a43ee800d35a162d99893f6a55f5a7c72"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html#a43ee800d35a162d99893f6a55f5a7c72">operator=</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:a43ee800d35a162d99893f6a55f5a7c72"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aee5b61e3b98fe989e78f96d2117d74d1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html#aee5b61e3b98fe989e78f96d2117d74d1">operator=</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:aee5b61e3b98fe989e78f96d2117d74d1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal3"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal3')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td></tr>
+<tr class="memitem:a52731959f272612fd6abfe8850c5c8cf inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a52731959f272612fd6abfe8850c5c8cf">signal3</a> ()</td></tr>
+<tr class="separator:a52731959f272612fd6abfe8850c5c8cf inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afe2c4320927b403b011a2538317e6c70 inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#afe2c4320927b403b011a2538317e6c70">signal3</a> (const <a class="el" href="classsigc_1_1signal3.html">signal3</a> & src)</td></tr>
+<tr class="separator:afe2c4320927b403b011a2538317e6c70 inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acd69c2a1d993f0b8993f82998f76020d inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#acd69c2a1d993f0b8993f82998f76020d">signal3</a> (<a class="el" href="classsigc_1_1signal3.html">signal3</a> && src)</td></tr>
+<tr class="separator:acd69c2a1d993f0b8993f82998f76020d inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3eae0b3796b2736be847f33a5124aacd inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a8029a48126a2018947a2b6680ddabe6b">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a3eae0b3796b2736be847f33a5124aacd">connect</a> (const <a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:a3eae0b3796b2736be847f33a5124aacd inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal3.html#a3eae0b3796b2736be847f33a5124aacd">More...</a><br /></td></tr>
+<tr class="separator:a3eae0b3796b2736be847f33a5124aacd inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad71389c6d6ea60e745897579b3344d00 inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a8029a48126a2018947a2b6680ddabe6b">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#ad71389c6d6ea60e745897579b3344d00">connect</a> (<a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:ad71389c6d6ea60e745897579b3344d00 inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal3.html#ad71389c6d6ea60e745897579b3344d00">More...</a><br /></td></tr>
+<tr class="separator:ad71389c6d6ea60e745897579b3344d00 inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8592e22e3780f2cdf19a568a8a116bbb inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:a8592e22e3780f2cdf19a568a8a116bbb inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb">More...</a><br /></td></tr>
+<tr class="separator:a8592e22e3780f2cdf19a568a8a116bbb inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a97ff4f22c97920a81e3f27aa5d39ba99 inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a97ff4f22c97920a81e3f27aa5d39ba99">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:a97ff4f22c97920a81e3f27aa5d39ba99 inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal3.html#a97ff4f22c97920a81e3f27aa5d39ba99">More...</a><br /></td></tr>
+<tr class="separator:a97ff4f22c97920a81e3f27aa5d39ba99 inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a332be8eb0ee22c11a2e1d140ca1bc2df inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html">bound_const_mem_functor3</a>< <a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a>, <a class="el" href="classsigc_1_1signal3.html">signal3</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a332be8eb0ee22c11a2e1d140ca1bc2df">make_slot</a> () const</td></tr>
+<tr class="memdesc:a332be8eb0ee22c11a2e1d140ca1bc2df inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal3.html#a332be8eb0ee22c11a2e1d140ca1bc2df">More...</a><br /></td></tr>
+<tr class="separator:a332be8eb0ee22c11a2e1d140ca1bc2df inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7ae5338d6a883a28c61ff202e43547f inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#aa7ae5338d6a883a28c61ff202e43547f">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:aa7ae5338d6a883a28c61ff202e43547f inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal3.html#aa7ae5338d6a883a28c61ff202e43547f">More...</a><br /></td></tr>
+<tr class="separator:aa7ae5338d6a883a28c61ff202e43547f inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0c398a25051e920bc4338f35b4bf7df6 inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html">signal3</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a0c398a25051e920bc4338f35b4bf7df6">operator=</a> (const <a class="el" href="classsigc_1_1signal3.html">signal3</a> & src)</td></tr>
+<tr class="separator:a0c398a25051e920bc4338f35b4bf7df6 inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abafd9fe17f2b9b18e25eb0293e9e8bfd inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html">signal3</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#abafd9fe17f2b9b18e25eb0293e9e8bfd">operator=</a> (<a class="el" href="classsigc_1_1signal3.html">signal3</a> && src)</td></tr>
+<tr class="separator:abafd9fe17f2b9b18e25eb0293e9e8bfd inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab9606b708078956a758b81503f956bee inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a3bc0616e7ac933e702a889a2a84e92d4">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#ab9606b708078956a758b81503f956bee">slots</a> ()</td></tr>
+<tr class="memdesc:ab9606b708078956a758b81503f956bee inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal3.html#ab9606b708078956a758b81503f956bee">More...</a><br /></td></tr>
+<tr class="separator:ab9606b708078956a758b81503f956bee inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a742eb282312187bf8ee6992df1114781 inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal3.html#a3bc0616e7ac933e702a889a2a84e92d4">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a742eb282312187bf8ee6992df1114781">slots</a> () const</td></tr>
+<tr class="memdesc:a742eb282312187bf8ee6992df1114781 inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal3.html#a742eb282312187bf8ee6992df1114781">More...</a><br /></td></tr>
+<tr class="separator:a742eb282312187bf8ee6992df1114781 inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal3"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal3')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td></tr>
+<tr class="memitem:a60e1ef95f82cd8981d61576d1e3f8e94 inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a60e1ef95f82cd8981d61576d1e3f8e94">const_iterator</a></td></tr>
+<tr class="separator:a60e1ef95f82cd8981d61576d1e3f8e94 inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4ba3eb58c4c5ac2c25f49c48fd0af264 inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a4ba3eb58c4c5ac2c25f49c48fd0af264">const_reverse_iterator</a></td></tr>
+<tr class="separator:a4ba3eb58c4c5ac2c25f49c48fd0af264 inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adf54ec96c5fb78d4c8b7fc032a1937ad inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit3< T_return, T_arg1, T_arg2, T_arg3, <a class="el" href="structsigc_1_1nil.html">nil</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#adf54ec96c5fb78d4c8b7fc032a1937ad">emitter_type</a></td></tr>
+<tr class="separator:adf54ec96c5fb78d4c8b7fc032a1937ad inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8029a48126a2018947a2b6680ddabe6b inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a8029a48126a2018947a2b6680ddabe6b">iterator</a></td></tr>
+<tr class="separator:a8029a48126a2018947a2b6680ddabe6b inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a57c79755fc4c4b04196a9bf6742a0cc6 inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a></td></tr>
+<tr class="separator:a57c79755fc4c4b04196a9bf6742a0cc6 inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acc453f0d5fc7f277494b2d6e737f6f68 inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#acc453f0d5fc7f277494b2d6e737f6f68">reverse_iterator</a></td></tr>
+<tr class="separator:acc453f0d5fc7f277494b2d6e737f6f68 inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3bc0616e7ac933e702a889a2a84e92d4 inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a3bc0616e7ac933e702a889a2a84e92d4">slot_list_type</a></td></tr>
+<tr class="separator:a3bc0616e7ac933e702a889a2a84e92d4 inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afe37478128b40fb4efedcd3c0eb05b6b inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2, T_arg3)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a></td></tr>
+<tr class="separator:afe37478128b40fb4efedcd3c0eb05b6b inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3><br />
+class sigc::signal< T_return(T_arg1, T_arg2, T_arg3)></h3>
+
+<p>This specialization allow use of the sigc::signal<R(Args...)> syntax,. </p>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a27d493742451c292a6c001b9353c08d9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a27d493742451c292a6c001b9353c08d9">◆ </a></span>signal() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3)>::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a51bd913df6a849d6dd720e8c19532149"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a51bd913df6a849d6dd720e8c19532149">◆ </a></span>signal() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3)>::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return(T_arg1, T_arg2, T_arg3)> & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ac22b59e41db40b6cbe6ac4b71d048170"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac22b59e41db40b6cbe6ac4b71d048170">◆ </a></span>signal() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3)>::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return(T_arg1, T_arg2, T_arg3)> && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a43ee800d35a162d99893f6a55f5a7c72"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a43ee800d35a162d99893f6a55f5a7c72">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3)>::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return(T_arg1, T_arg2, T_arg3)> & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aee5b61e3b98fe989e78f96d2117d74d1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aee5b61e3b98fe989e78f96d2117d74d1">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3)>::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return(T_arg1, T_arg2, T_arg3)> && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3)></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return(T_arg1, T_arg2, T_arg3)>::accumulated< T_accumulator > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3)>::accumulated< T_accumulator ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html#a096e447ba082bebd28601309d595807c">accumulated</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3)>::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html#ad47d6448e3137d45649656d23b19f89a">accumulated</a>(const accumulated & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3)>::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a3eae0b3796b2736be847f33a5124aacd">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#ad71389c6d6ea60e745897579b3344d00">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a60e1ef95f82cd8981d61576d1e3f8e94">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a4ba3eb58c4c5ac2c25f49c48fd0af264">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a97ff4f22c97920a81e3f27aa5d39ba99">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#adf54ec96c5fb78d4c8b7fc032a1937ad">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a8029a48126a2018947a2b6680ddabe6b">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a332be8eb0ee22c11a2e1d140ca1bc2df">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#aa7ae5338d6a883a28c61ff202e43547f">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a0c398a25051e920bc4338f35b4bf7df6">operator=</a>(const signal3 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#abafd9fe17f2b9b18e25eb0293e9e8bfd">operator=</a>(signal3 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#acc453f0d5fc7f277494b2d6e737f6f68">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a52731959f272612fd6abfe8850c5c8cf">signal3</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#afe2c4320927b403b011a2538317e6c70">signal3</a>(const signal3 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#acd69c2a1d993f0b8993f82998f76020d">signal3</a>(signal3 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a3bc0616e7ac933e702a889a2a84e92d4">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal3.html#ab9606b708078956a758b81503f956bee">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal3.html#a742eb282312187bf8ee6992df1114781">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return(T_arg1, T_arg2, T_arg3)>::accumulated< T_accumulator > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3)></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return(T_arg1, T_arg2, T_arg3)>::accumulated< T_accumulator > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal3.html" title="Signal declaration.">sigc::signal3</a> template.
+ <a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return(T_arg1, T_arg2, T_arg3)>::accumulated< T_accumulator >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated__inherit__graph.png" border="0" usemap="#asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" id="asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::signal3 template." alt="" coords="5,259,256,315"/>
+<area shape="rect" href="classsigc_1_1signal3.html" title=" " alt="" coords="41,155,220,211"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="64,80,197,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="73,5,189,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a096e447ba082bebd28601309d595807c"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html#a096e447ba082bebd28601309d595807c">accumulated</a> ()</td></tr>
+<tr class="separator:a096e447ba082bebd28601309d595807c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad47d6448e3137d45649656d23b19f89a"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html#ad47d6448e3137d45649656d23b19f89a">accumulated</a> (const accumulated & src)</td></tr>
+<tr class="separator:ad47d6448e3137d45649656d23b19f89a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal3"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal3')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td></tr>
+<tr class="memitem:a52731959f272612fd6abfe8850c5c8cf inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a52731959f272612fd6abfe8850c5c8cf">signal3</a> ()</td></tr>
+<tr class="separator:a52731959f272612fd6abfe8850c5c8cf inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afe2c4320927b403b011a2538317e6c70 inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#afe2c4320927b403b011a2538317e6c70">signal3</a> (const <a class="el" href="classsigc_1_1signal3.html">signal3</a> & src)</td></tr>
+<tr class="separator:afe2c4320927b403b011a2538317e6c70 inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acd69c2a1d993f0b8993f82998f76020d inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#acd69c2a1d993f0b8993f82998f76020d">signal3</a> (<a class="el" href="classsigc_1_1signal3.html">signal3</a> && src)</td></tr>
+<tr class="separator:acd69c2a1d993f0b8993f82998f76020d inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3eae0b3796b2736be847f33a5124aacd inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a8029a48126a2018947a2b6680ddabe6b">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a3eae0b3796b2736be847f33a5124aacd">connect</a> (const <a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:a3eae0b3796b2736be847f33a5124aacd inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal3.html#a3eae0b3796b2736be847f33a5124aacd">More...</a><br /></td></tr>
+<tr class="separator:a3eae0b3796b2736be847f33a5124aacd inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad71389c6d6ea60e745897579b3344d00 inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a8029a48126a2018947a2b6680ddabe6b">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#ad71389c6d6ea60e745897579b3344d00">connect</a> (<a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:ad71389c6d6ea60e745897579b3344d00 inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal3.html#ad71389c6d6ea60e745897579b3344d00">More...</a><br /></td></tr>
+<tr class="separator:ad71389c6d6ea60e745897579b3344d00 inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8592e22e3780f2cdf19a568a8a116bbb inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:a8592e22e3780f2cdf19a568a8a116bbb inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb">More...</a><br /></td></tr>
+<tr class="separator:a8592e22e3780f2cdf19a568a8a116bbb inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a97ff4f22c97920a81e3f27aa5d39ba99 inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a97ff4f22c97920a81e3f27aa5d39ba99">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:a97ff4f22c97920a81e3f27aa5d39ba99 inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal3.html#a97ff4f22c97920a81e3f27aa5d39ba99">More...</a><br /></td></tr>
+<tr class="separator:a97ff4f22c97920a81e3f27aa5d39ba99 inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a332be8eb0ee22c11a2e1d140ca1bc2df inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html">bound_const_mem_functor3</a>< <a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a>, <a class="el" href="classsigc_1_1signal3.html">signal3</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a332be8eb0ee22c11a2e1d140ca1bc2df">make_slot</a> () const</td></tr>
+<tr class="memdesc:a332be8eb0ee22c11a2e1d140ca1bc2df inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal3.html#a332be8eb0ee22c11a2e1d140ca1bc2df">More...</a><br /></td></tr>
+<tr class="separator:a332be8eb0ee22c11a2e1d140ca1bc2df inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7ae5338d6a883a28c61ff202e43547f inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#aa7ae5338d6a883a28c61ff202e43547f">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:aa7ae5338d6a883a28c61ff202e43547f inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal3.html#aa7ae5338d6a883a28c61ff202e43547f">More...</a><br /></td></tr>
+<tr class="separator:aa7ae5338d6a883a28c61ff202e43547f inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0c398a25051e920bc4338f35b4bf7df6 inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html">signal3</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a0c398a25051e920bc4338f35b4bf7df6">operator=</a> (const <a class="el" href="classsigc_1_1signal3.html">signal3</a> & src)</td></tr>
+<tr class="separator:a0c398a25051e920bc4338f35b4bf7df6 inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abafd9fe17f2b9b18e25eb0293e9e8bfd inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html">signal3</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#abafd9fe17f2b9b18e25eb0293e9e8bfd">operator=</a> (<a class="el" href="classsigc_1_1signal3.html">signal3</a> && src)</td></tr>
+<tr class="separator:abafd9fe17f2b9b18e25eb0293e9e8bfd inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab9606b708078956a758b81503f956bee inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal3.html#a3bc0616e7ac933e702a889a2a84e92d4">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#ab9606b708078956a758b81503f956bee">slots</a> ()</td></tr>
+<tr class="memdesc:ab9606b708078956a758b81503f956bee inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal3.html#ab9606b708078956a758b81503f956bee">More...</a><br /></td></tr>
+<tr class="separator:ab9606b708078956a758b81503f956bee inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a742eb282312187bf8ee6992df1114781 inherit pub_methods_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal3.html#a3bc0616e7ac933e702a889a2a84e92d4">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a742eb282312187bf8ee6992df1114781">slots</a> () const</td></tr>
+<tr class="memdesc:a742eb282312187bf8ee6992df1114781 inherit pub_methods_classsigc_1_1signal3"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal3.html#a742eb282312187bf8ee6992df1114781">More...</a><br /></td></tr>
+<tr class="separator:a742eb282312187bf8ee6992df1114781 inherit pub_methods_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal3"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal3')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td></tr>
+<tr class="memitem:a60e1ef95f82cd8981d61576d1e3f8e94 inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a60e1ef95f82cd8981d61576d1e3f8e94">const_iterator</a></td></tr>
+<tr class="separator:a60e1ef95f82cd8981d61576d1e3f8e94 inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4ba3eb58c4c5ac2c25f49c48fd0af264 inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a4ba3eb58c4c5ac2c25f49c48fd0af264">const_reverse_iterator</a></td></tr>
+<tr class="separator:a4ba3eb58c4c5ac2c25f49c48fd0af264 inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adf54ec96c5fb78d4c8b7fc032a1937ad inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#adf54ec96c5fb78d4c8b7fc032a1937ad">emitter_type</a></td></tr>
+<tr class="separator:adf54ec96c5fb78d4c8b7fc032a1937ad inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8029a48126a2018947a2b6680ddabe6b inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a8029a48126a2018947a2b6680ddabe6b">iterator</a></td></tr>
+<tr class="separator:a8029a48126a2018947a2b6680ddabe6b inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a57c79755fc4c4b04196a9bf6742a0cc6 inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">result_type</a></td></tr>
+<tr class="separator:a57c79755fc4c4b04196a9bf6742a0cc6 inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acc453f0d5fc7f277494b2d6e737f6f68 inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#acc453f0d5fc7f277494b2d6e737f6f68">reverse_iterator</a></td></tr>
+<tr class="separator:acc453f0d5fc7f277494b2d6e737f6f68 inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3bc0616e7ac933e702a889a2a84e92d4 inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#a3bc0616e7ac933e702a889a2a84e92d4">slot_list_type</a></td></tr>
+<tr class="separator:a3bc0616e7ac933e702a889a2a84e92d4 inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afe37478128b40fb4efedcd3c0eb05b6b inherit pub_types_classsigc_1_1signal3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2, T_arg3)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">slot_type</a></td></tr>
+<tr class="separator:afe37478128b40fb4efedcd3c0eb05b6b inherit pub_types_classsigc_1_1signal3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3><br />
+template <class T_accumulator><br />
+class sigc::signal< T_return(T_arg1, T_arg2, T_arg3)>::accumulated< T_accumulator ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal3.html" title="Signal declaration.">sigc::signal3</a> template. </p>
+<p>Like <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> but the additional template parameter <em>T_accumulator</em> defines the accumulator type that should be used. </p>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a096e447ba082bebd28601309d595807c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a096e447ba082bebd28601309d595807c">◆ </a></span>accumulated() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3)>::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ad47d6448e3137d45649656d23b19f89a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad47d6448e3137d45649656d23b19f89a">◆ </a></span>accumulated() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2, T_arg3)>::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramtype">const accumulated & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal< T_return(T_arg1, T_arg2, T_arg3)>::accumulated< T_accumulator >" name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3)>::accumulated< T_accumulator >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::signal3 template." alt="" coords="5,259,256,315"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal3.html" title=" " alt="" coords="41,155,220,211"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="64,80,197,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="73,5,189,32"/>
+</map>
--- /dev/null
+d046202d34f5f8f8abeb8bd11831cf05
\ No newline at end of file
--- /dev/null
+<map id="sigc::signal< T_return(T_arg1, T_arg2, T_arg3)>" name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3)>">
+<area shape="rect" id="node1" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="5,259,196,300"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal3.html" title=" " alt="" coords="11,155,190,211"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="34,80,167,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="43,5,159,32"/>
+</map>
--- /dev/null
+296bb16095bda83978b434106c4d915a
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html">signal< T_return(T_arg1, T_arg2)></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return(T_arg1, T_arg2)> Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html">sigc::signal< T_return(T_arg1, T_arg2)></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#aa686af4f961b098a23d4f7276437c2b0">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#ab89b1876c69ea40954b0af37e75a21b4">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#ad507bc5ea29adb2305f8fa91acbd30ee">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#aacb8fe57ffe01dea5c5fb5af44634287">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#ad2d5f3169ba147de8d43fde9e93bac98">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a01379d580d21de8bc8d0d2d62e6324ea">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a658ba1c6468882c9b1d480be2bbaf55e">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a844d15c61c83933575e7953b29365efa">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#ac8b73c0624273b8dae819255961ea6a3">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html#abdcf63e52e05fd88654a7e688abd57b1">operator=</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html">sigc::signal< T_return(T_arg1, T_arg2)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html#a925adc69603e7caab05920baf7f80faf">operator=</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html">sigc::signal< T_return(T_arg1, T_arg2)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#abeb05d9a2b40882bad753fccad6522be">signal2< T_return, T_arg1, T_arg2, nil >::operator=</a>(const signal2 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a5d3f71fb9ee8754c4640fb5bfb954151">signal2< T_return, T_arg1, T_arg2, nil >::operator=</a>(signal2 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a6710759bdeb8e626fc09d8c448e6613f">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html#a9d8fa2e7dd971a359c53c5ed19310f00">signal</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html">sigc::signal< T_return(T_arg1, T_arg2)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html#a13d95a6b3058ddbd0f55fd00953cdee5">signal</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html">sigc::signal< T_return(T_arg1, T_arg2)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html#acc41707d3187fe1ac6bb9180f82428a7">signal</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html">sigc::signal< T_return(T_arg1, T_arg2)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a47aba9b19bc2bef0be7183022567e3ea">signal2</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#aa634515507f2ea4a35584e12e2dc92e7">signal2</a>(const signal2 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a20c59f06175d4c48394c65035d2c3376">signal2</a>(signal2 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#af31262f54dfb2a97540de9c4a1fc5726">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#ac28b0205aa1e60cc5ce062d4d8545323">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#aa6be4804147afd56657abf5b4cf8ce3d">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return(T_arg1, T_arg2)> Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html">signal< T_return(T_arg1, T_arg2)></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#nested-classes">Classes</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return(T_arg1, T_arg2)> Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This specialization allow use of the sigc::signal<R(Args...)> syntax,.
+ <a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return(T_arg1, T_arg2)>:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4__inherit__graph.png" border="0" usemap="#asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_inherit__map" id="asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_inherit__map">
+<area shape="rect" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="11,244,175,285"/>
+<area shape="rect" href="classsigc_1_1signal2.html" title=" " alt="" coords="5,155,181,196"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="27,80,160,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="35,5,151,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Classes</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html">accumulated</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal2.html" title="Signal declaration.">sigc::signal2</a> template. <a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a9d8fa2e7dd971a359c53c5ed19310f00"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html#a9d8fa2e7dd971a359c53c5ed19310f00">signal</a> ()</td></tr>
+<tr class="separator:a9d8fa2e7dd971a359c53c5ed19310f00"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a13d95a6b3058ddbd0f55fd00953cdee5"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html#a13d95a6b3058ddbd0f55fd00953cdee5">signal</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:a13d95a6b3058ddbd0f55fd00953cdee5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acc41707d3187fe1ac6bb9180f82428a7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html#acc41707d3187fe1ac6bb9180f82428a7">signal</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:acc41707d3187fe1ac6bb9180f82428a7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abdcf63e52e05fd88654a7e688abd57b1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html#abdcf63e52e05fd88654a7e688abd57b1">operator=</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:abdcf63e52e05fd88654a7e688abd57b1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a925adc69603e7caab05920baf7f80faf"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html#a925adc69603e7caab05920baf7f80faf">operator=</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:a925adc69603e7caab05920baf7f80faf"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal2"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal2')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td></tr>
+<tr class="memitem:a47aba9b19bc2bef0be7183022567e3ea inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a47aba9b19bc2bef0be7183022567e3ea">signal2</a> ()</td></tr>
+<tr class="separator:a47aba9b19bc2bef0be7183022567e3ea inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa634515507f2ea4a35584e12e2dc92e7 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#aa634515507f2ea4a35584e12e2dc92e7">signal2</a> (const <a class="el" href="classsigc_1_1signal2.html">signal2</a> & src)</td></tr>
+<tr class="separator:aa634515507f2ea4a35584e12e2dc92e7 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a20c59f06175d4c48394c65035d2c3376 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a20c59f06175d4c48394c65035d2c3376">signal2</a> (<a class="el" href="classsigc_1_1signal2.html">signal2</a> && src)</td></tr>
+<tr class="separator:a20c59f06175d4c48394c65035d2c3376 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa686af4f961b098a23d4f7276437c2b0 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#a658ba1c6468882c9b1d480be2bbaf55e">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#aa686af4f961b098a23d4f7276437c2b0">connect</a> (const <a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:aa686af4f961b098a23d4f7276437c2b0 inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal2.html#aa686af4f961b098a23d4f7276437c2b0">More...</a><br /></td></tr>
+<tr class="separator:aa686af4f961b098a23d4f7276437c2b0 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab89b1876c69ea40954b0af37e75a21b4 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#a658ba1c6468882c9b1d480be2bbaf55e">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#ab89b1876c69ea40954b0af37e75a21b4">connect</a> (<a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:ab89b1876c69ea40954b0af37e75a21b4 inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal2.html#ab89b1876c69ea40954b0af37e75a21b4">More...</a><br /></td></tr>
+<tr class="separator:ab89b1876c69ea40954b0af37e75a21b4 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afd12e2a266a6399cc32e888d6f5e6f2f inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:afd12e2a266a6399cc32e888d6f5e6f2f inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f">More...</a><br /></td></tr>
+<tr class="separator:afd12e2a266a6399cc32e888d6f5e6f2f inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad2d5f3169ba147de8d43fde9e93bac98 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#ad2d5f3169ba147de8d43fde9e93bac98">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:ad2d5f3169ba147de8d43fde9e93bac98 inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal2.html#ad2d5f3169ba147de8d43fde9e93bac98">More...</a><br /></td></tr>
+<tr class="separator:ad2d5f3169ba147de8d43fde9e93bac98 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a844d15c61c83933575e7953b29365efa inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html">bound_const_mem_functor2</a>< <a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a>, <a class="el" href="classsigc_1_1signal2.html">signal2</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a844d15c61c83933575e7953b29365efa">make_slot</a> () const</td></tr>
+<tr class="memdesc:a844d15c61c83933575e7953b29365efa inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal2.html#a844d15c61c83933575e7953b29365efa">More...</a><br /></td></tr>
+<tr class="separator:a844d15c61c83933575e7953b29365efa inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8b73c0624273b8dae819255961ea6a3 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#ac8b73c0624273b8dae819255961ea6a3">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:ac8b73c0624273b8dae819255961ea6a3 inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal2.html#ac8b73c0624273b8dae819255961ea6a3">More...</a><br /></td></tr>
+<tr class="separator:ac8b73c0624273b8dae819255961ea6a3 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abeb05d9a2b40882bad753fccad6522be inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html">signal2</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#abeb05d9a2b40882bad753fccad6522be">operator=</a> (const <a class="el" href="classsigc_1_1signal2.html">signal2</a> & src)</td></tr>
+<tr class="separator:abeb05d9a2b40882bad753fccad6522be inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5d3f71fb9ee8754c4640fb5bfb954151 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html">signal2</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a5d3f71fb9ee8754c4640fb5bfb954151">operator=</a> (<a class="el" href="classsigc_1_1signal2.html">signal2</a> && src)</td></tr>
+<tr class="separator:a5d3f71fb9ee8754c4640fb5bfb954151 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac28b0205aa1e60cc5ce062d4d8545323 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#af31262f54dfb2a97540de9c4a1fc5726">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#ac28b0205aa1e60cc5ce062d4d8545323">slots</a> ()</td></tr>
+<tr class="memdesc:ac28b0205aa1e60cc5ce062d4d8545323 inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal2.html#ac28b0205aa1e60cc5ce062d4d8545323">More...</a><br /></td></tr>
+<tr class="separator:ac28b0205aa1e60cc5ce062d4d8545323 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa6be4804147afd56657abf5b4cf8ce3d inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal2.html#af31262f54dfb2a97540de9c4a1fc5726">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#aa6be4804147afd56657abf5b4cf8ce3d">slots</a> () const</td></tr>
+<tr class="memdesc:aa6be4804147afd56657abf5b4cf8ce3d inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal2.html#aa6be4804147afd56657abf5b4cf8ce3d">More...</a><br /></td></tr>
+<tr class="separator:aa6be4804147afd56657abf5b4cf8ce3d inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal2"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal2')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td></tr>
+<tr class="memitem:ad507bc5ea29adb2305f8fa91acbd30ee inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#ad507bc5ea29adb2305f8fa91acbd30ee">const_iterator</a></td></tr>
+<tr class="separator:ad507bc5ea29adb2305f8fa91acbd30ee inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aacb8fe57ffe01dea5c5fb5af44634287 inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#aacb8fe57ffe01dea5c5fb5af44634287">const_reverse_iterator</a></td></tr>
+<tr class="separator:aacb8fe57ffe01dea5c5fb5af44634287 inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a01379d580d21de8bc8d0d2d62e6324ea inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit2< T_return, T_arg1, T_arg2, <a class="el" href="structsigc_1_1nil.html">nil</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a01379d580d21de8bc8d0d2d62e6324ea">emitter_type</a></td></tr>
+<tr class="separator:a01379d580d21de8bc8d0d2d62e6324ea inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a658ba1c6468882c9b1d480be2bbaf55e inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a658ba1c6468882c9b1d480be2bbaf55e">iterator</a></td></tr>
+<tr class="separator:a658ba1c6468882c9b1d480be2bbaf55e inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a55151695417c33540357ff524bfe2665 inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a></td></tr>
+<tr class="separator:a55151695417c33540357ff524bfe2665 inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a6710759bdeb8e626fc09d8c448e6613f inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a6710759bdeb8e626fc09d8c448e6613f">reverse_iterator</a></td></tr>
+<tr class="separator:a6710759bdeb8e626fc09d8c448e6613f inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af31262f54dfb2a97540de9c4a1fc5726 inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#af31262f54dfb2a97540de9c4a1fc5726">slot_list_type</a></td></tr>
+<tr class="separator:af31262f54dfb2a97540de9c4a1fc5726 inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af7797ae10e76307f8d230588e760f119 inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a></td></tr>
+<tr class="separator:af7797ae10e76307f8d230588e760f119 inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2><br />
+class sigc::signal< T_return(T_arg1, T_arg2)></h3>
+
+<p>This specialization allow use of the sigc::signal<R(Args...)> syntax,. </p>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a9d8fa2e7dd971a359c53c5ed19310f00"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9d8fa2e7dd971a359c53c5ed19310f00">◆ </a></span>signal() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2)>::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a13d95a6b3058ddbd0f55fd00953cdee5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a13d95a6b3058ddbd0f55fd00953cdee5">◆ </a></span>signal() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2)>::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return(T_arg1, T_arg2)> & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="acc41707d3187fe1ac6bb9180f82428a7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#acc41707d3187fe1ac6bb9180f82428a7">◆ </a></span>signal() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2)>::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return(T_arg1, T_arg2)> && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="abdcf63e52e05fd88654a7e688abd57b1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abdcf63e52e05fd88654a7e688abd57b1">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2)>::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return(T_arg1, T_arg2)> & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a925adc69603e7caab05920baf7f80faf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a925adc69603e7caab05920baf7f80faf">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2)>::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return(T_arg1, T_arg2)> && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html">signal< T_return(T_arg1, T_arg2)></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return(T_arg1, T_arg2)>::accumulated< T_accumulator > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html">sigc::signal< T_return(T_arg1, T_arg2)>::accumulated< T_accumulator ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html#abf5d54ba4c8e7f2792be010df45df59b">accumulated</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html">sigc::signal< T_return(T_arg1, T_arg2)>::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html#af6082d36c41f676b54f271f31ca781b6">accumulated</a>(const accumulated & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html">sigc::signal< T_return(T_arg1, T_arg2)>::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#aa686af4f961b098a23d4f7276437c2b0">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#ab89b1876c69ea40954b0af37e75a21b4">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#ad507bc5ea29adb2305f8fa91acbd30ee">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#aacb8fe57ffe01dea5c5fb5af44634287">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f">emit</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#ad2d5f3169ba147de8d43fde9e93bac98">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a01379d580d21de8bc8d0d2d62e6324ea">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a658ba1c6468882c9b1d480be2bbaf55e">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a844d15c61c83933575e7953b29365efa">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#ac8b73c0624273b8dae819255961ea6a3">operator()</a>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#abeb05d9a2b40882bad753fccad6522be">operator=</a>(const signal2 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a5d3f71fb9ee8754c4640fb5bfb954151">operator=</a>(signal2 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a6710759bdeb8e626fc09d8c448e6613f">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a47aba9b19bc2bef0be7183022567e3ea">signal2</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#aa634515507f2ea4a35584e12e2dc92e7">signal2</a>(const signal2 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#a20c59f06175d4c48394c65035d2c3376">signal2</a>(signal2 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#af31262f54dfb2a97540de9c4a1fc5726">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal2.html#ac28b0205aa1e60cc5ce062d4d8545323">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal2.html#aa6be4804147afd56657abf5b4cf8ce3d">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return(T_arg1, T_arg2)>::accumulated< T_accumulator > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html">signal< T_return(T_arg1, T_arg2)></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return(T_arg1, T_arg2)>::accumulated< T_accumulator > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal2.html" title="Signal declaration.">sigc::signal2</a> template.
+ <a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return(T_arg1, T_arg2)>::accumulated< T_accumulator >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated__inherit__graph.png" border="0" usemap="#asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" id="asigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::signal2 template." alt="" coords="11,244,241,300"/>
+<area shape="rect" href="classsigc_1_1signal2.html" title=" " alt="" coords="5,155,247,196"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="59,80,193,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="68,5,184,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:abf5d54ba4c8e7f2792be010df45df59b"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html#abf5d54ba4c8e7f2792be010df45df59b">accumulated</a> ()</td></tr>
+<tr class="separator:abf5d54ba4c8e7f2792be010df45df59b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af6082d36c41f676b54f271f31ca781b6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html#af6082d36c41f676b54f271f31ca781b6">accumulated</a> (const accumulated & src)</td></tr>
+<tr class="separator:af6082d36c41f676b54f271f31ca781b6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal2"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal2')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td></tr>
+<tr class="memitem:a47aba9b19bc2bef0be7183022567e3ea inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a47aba9b19bc2bef0be7183022567e3ea">signal2</a> ()</td></tr>
+<tr class="separator:a47aba9b19bc2bef0be7183022567e3ea inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa634515507f2ea4a35584e12e2dc92e7 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#aa634515507f2ea4a35584e12e2dc92e7">signal2</a> (const <a class="el" href="classsigc_1_1signal2.html">signal2</a> & src)</td></tr>
+<tr class="separator:aa634515507f2ea4a35584e12e2dc92e7 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a20c59f06175d4c48394c65035d2c3376 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a20c59f06175d4c48394c65035d2c3376">signal2</a> (<a class="el" href="classsigc_1_1signal2.html">signal2</a> && src)</td></tr>
+<tr class="separator:a20c59f06175d4c48394c65035d2c3376 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa686af4f961b098a23d4f7276437c2b0 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#a658ba1c6468882c9b1d480be2bbaf55e">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#aa686af4f961b098a23d4f7276437c2b0">connect</a> (const <a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:aa686af4f961b098a23d4f7276437c2b0 inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal2.html#aa686af4f961b098a23d4f7276437c2b0">More...</a><br /></td></tr>
+<tr class="separator:aa686af4f961b098a23d4f7276437c2b0 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab89b1876c69ea40954b0af37e75a21b4 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#a658ba1c6468882c9b1d480be2bbaf55e">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#ab89b1876c69ea40954b0af37e75a21b4">connect</a> (<a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:ab89b1876c69ea40954b0af37e75a21b4 inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal2.html#ab89b1876c69ea40954b0af37e75a21b4">More...</a><br /></td></tr>
+<tr class="separator:ab89b1876c69ea40954b0af37e75a21b4 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afd12e2a266a6399cc32e888d6f5e6f2f inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:afd12e2a266a6399cc32e888d6f5e6f2f inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f">More...</a><br /></td></tr>
+<tr class="separator:afd12e2a266a6399cc32e888d6f5e6f2f inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad2d5f3169ba147de8d43fde9e93bac98 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#ad2d5f3169ba147de8d43fde9e93bac98">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:ad2d5f3169ba147de8d43fde9e93bac98 inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal2.html#ad2d5f3169ba147de8d43fde9e93bac98">More...</a><br /></td></tr>
+<tr class="separator:ad2d5f3169ba147de8d43fde9e93bac98 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a844d15c61c83933575e7953b29365efa inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html">bound_const_mem_functor2</a>< <a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a>, <a class="el" href="classsigc_1_1signal2.html">signal2</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 >, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a844d15c61c83933575e7953b29365efa">make_slot</a> () const</td></tr>
+<tr class="memdesc:a844d15c61c83933575e7953b29365efa inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal2.html#a844d15c61c83933575e7953b29365efa">More...</a><br /></td></tr>
+<tr class="separator:a844d15c61c83933575e7953b29365efa inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8b73c0624273b8dae819255961ea6a3 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#ac8b73c0624273b8dae819255961ea6a3">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:ac8b73c0624273b8dae819255961ea6a3 inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal2.html#ac8b73c0624273b8dae819255961ea6a3">More...</a><br /></td></tr>
+<tr class="separator:ac8b73c0624273b8dae819255961ea6a3 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abeb05d9a2b40882bad753fccad6522be inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html">signal2</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#abeb05d9a2b40882bad753fccad6522be">operator=</a> (const <a class="el" href="classsigc_1_1signal2.html">signal2</a> & src)</td></tr>
+<tr class="separator:abeb05d9a2b40882bad753fccad6522be inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5d3f71fb9ee8754c4640fb5bfb954151 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html">signal2</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a5d3f71fb9ee8754c4640fb5bfb954151">operator=</a> (<a class="el" href="classsigc_1_1signal2.html">signal2</a> && src)</td></tr>
+<tr class="separator:a5d3f71fb9ee8754c4640fb5bfb954151 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac28b0205aa1e60cc5ce062d4d8545323 inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal2.html#af31262f54dfb2a97540de9c4a1fc5726">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#ac28b0205aa1e60cc5ce062d4d8545323">slots</a> ()</td></tr>
+<tr class="memdesc:ac28b0205aa1e60cc5ce062d4d8545323 inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal2.html#ac28b0205aa1e60cc5ce062d4d8545323">More...</a><br /></td></tr>
+<tr class="separator:ac28b0205aa1e60cc5ce062d4d8545323 inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa6be4804147afd56657abf5b4cf8ce3d inherit pub_methods_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal2.html#af31262f54dfb2a97540de9c4a1fc5726">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#aa6be4804147afd56657abf5b4cf8ce3d">slots</a> () const</td></tr>
+<tr class="memdesc:aa6be4804147afd56657abf5b4cf8ce3d inherit pub_methods_classsigc_1_1signal2"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal2.html#aa6be4804147afd56657abf5b4cf8ce3d">More...</a><br /></td></tr>
+<tr class="separator:aa6be4804147afd56657abf5b4cf8ce3d inherit pub_methods_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal2"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal2')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td></tr>
+<tr class="memitem:ad507bc5ea29adb2305f8fa91acbd30ee inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#ad507bc5ea29adb2305f8fa91acbd30ee">const_iterator</a></td></tr>
+<tr class="separator:ad507bc5ea29adb2305f8fa91acbd30ee inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aacb8fe57ffe01dea5c5fb5af44634287 inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#aacb8fe57ffe01dea5c5fb5af44634287">const_reverse_iterator</a></td></tr>
+<tr class="separator:aacb8fe57ffe01dea5c5fb5af44634287 inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a01379d580d21de8bc8d0d2d62e6324ea inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit2< T_return, T_arg1, T_arg2, T_accumulator > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a01379d580d21de8bc8d0d2d62e6324ea">emitter_type</a></td></tr>
+<tr class="separator:a01379d580d21de8bc8d0d2d62e6324ea inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a658ba1c6468882c9b1d480be2bbaf55e inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a658ba1c6468882c9b1d480be2bbaf55e">iterator</a></td></tr>
+<tr class="separator:a658ba1c6468882c9b1d480be2bbaf55e inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a55151695417c33540357ff524bfe2665 inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">result_type</a></td></tr>
+<tr class="separator:a55151695417c33540357ff524bfe2665 inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a6710759bdeb8e626fc09d8c448e6613f inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#a6710759bdeb8e626fc09d8c448e6613f">reverse_iterator</a></td></tr>
+<tr class="separator:a6710759bdeb8e626fc09d8c448e6613f inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af31262f54dfb2a97540de9c4a1fc5726 inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#af31262f54dfb2a97540de9c4a1fc5726">slot_list_type</a></td></tr>
+<tr class="separator:af31262f54dfb2a97540de9c4a1fc5726 inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af7797ae10e76307f8d230588e760f119 inherit pub_types_classsigc_1_1signal2"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1, T_arg2)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">slot_type</a></td></tr>
+<tr class="separator:af7797ae10e76307f8d230588e760f119 inherit pub_types_classsigc_1_1signal2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2><br />
+template <class T_accumulator><br />
+class sigc::signal< T_return(T_arg1, T_arg2)>::accumulated< T_accumulator ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal2.html" title="Signal declaration.">sigc::signal2</a> template. </p>
+<p>Like <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> but the additional template parameter <em>T_accumulator</em> defines the accumulator type that should be used. </p>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="abf5d54ba4c8e7f2792be010df45df59b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abf5d54ba4c8e7f2792be010df45df59b">◆ </a></span>accumulated() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2)>::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="af6082d36c41f676b54f271f31ca781b6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af6082d36c41f676b54f271f31ca781b6">◆ </a></span>accumulated() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1, T_arg2)>::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramtype">const accumulated & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal< T_return(T_arg1, T_arg2)>::accumulated< T_accumulator >" name="sigc::signal< T_return(T_arg1, T_arg2)>::accumulated< T_accumulator >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::signal2 template." alt="" coords="11,244,241,300"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal2.html" title=" " alt="" coords="5,155,247,196"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="59,80,193,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="68,5,184,32"/>
+</map>
--- /dev/null
+dac03da4eb202bf95b4464608257d6d3
\ No newline at end of file
--- /dev/null
+<map id="sigc::signal< T_return(T_arg1, T_arg2)>" name="sigc::signal< T_return(T_arg1, T_arg2)>">
+<area shape="rect" id="node1" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="11,244,175,285"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal2.html" title=" " alt="" coords="5,155,181,196"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="27,80,160,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="35,5,151,32"/>
+</map>
--- /dev/null
+cbd7d620b85683456bfe16a1beab6eb7
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html">signal< T_return(T_arg1)></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return(T_arg1)> Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html">sigc::signal< T_return(T_arg1)></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#aac2ade0896bd4a982777d5dd6ac75888">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#ac69d2681c586b310d8c056a319bb65fe">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#af1e262b35c9574e65b2607cdfcaad707">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#aeb327519f808dfec9a723511ef82caa3">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42">emit</a>(type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a449fc940ae822c4b6ea9282b9b292015">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a63c6e2b55c8c3af083402bb7f5a66593">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#ab61e2d1fcaf903dffbb26b01800907fb">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a87513117263fd39d5a5a86e0fb8b2a78">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a828907c11f5c18d9522e5d5139484620">operator()</a>(type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html#a20f539ef645cba235c03d8d13f221ae5">operator=</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html">sigc::signal< T_return(T_arg1)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html#a1014db39eed6f085ab79116510005e4c">operator=</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html">sigc::signal< T_return(T_arg1)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a29cd06bf91f96f11c5f29237b8afbb71">signal1< T_return, T_arg1, nil >::operator=</a>(const signal1 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#ab817711d4bc93402d15e87b89a09c364">signal1< T_return, T_arg1, nil >::operator=</a>(signal1 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#ab0443049aa736d88770d0f534600b2bc">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html#a2e6e6d55741d1ef7e4ef3cf1a385ccf1">signal</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html">sigc::signal< T_return(T_arg1)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html#a41a5c99993530756404583e4fbc748ba">signal</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html">sigc::signal< T_return(T_arg1)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html#acc30f0949e699fbff85d341162298761">signal</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html">sigc::signal< T_return(T_arg1)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#aba62d8d0b9591bcfd728f8ae8a22d600">signal1</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#ab3378dd754ffddb4760f2a3afb271dbe">signal1</a>(const signal1 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a85ec968e0b25ee9285f297da5416b2a4">signal1</a>(signal1 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a5fadeb350140d6aaf560b217e7e7c4b4">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a7653b68e6a3b8445de91f89060bf2600">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a7777660b21fef2a6941c7dff23964604">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return(T_arg1)> Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html">signal< T_return(T_arg1)></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#nested-classes">Classes</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return(T_arg1)> Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This specialization allow use of the sigc::signal<R(Args...)> syntax,.
+ <a href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return(T_arg1)>:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_07T__arg1_08_4__inherit__graph.png" border="0" usemap="#asigc_1_1signal_3_01T__return_07T__arg1_08_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_07T__arg1_08_4_inherit__map" id="asigc_1_1signal_3_01T__return_07T__arg1_08_4_inherit__map">
+<area shape="rect" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="11,244,175,285"/>
+<area shape="rect" href="classsigc_1_1signal1.html" title=" " alt="" coords="5,155,181,196"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="27,80,160,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="35,5,151,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Classes</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html">accumulated</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal1.html" title="Signal declaration.">sigc::signal1</a> template. <a href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a2e6e6d55741d1ef7e4ef3cf1a385ccf1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html#a2e6e6d55741d1ef7e4ef3cf1a385ccf1">signal</a> ()</td></tr>
+<tr class="separator:a2e6e6d55741d1ef7e4ef3cf1a385ccf1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a41a5c99993530756404583e4fbc748ba"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html#a41a5c99993530756404583e4fbc748ba">signal</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:a41a5c99993530756404583e4fbc748ba"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acc30f0949e699fbff85d341162298761"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html#acc30f0949e699fbff85d341162298761">signal</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:acc30f0949e699fbff85d341162298761"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a20f539ef645cba235c03d8d13f221ae5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html#a20f539ef645cba235c03d8d13f221ae5">operator=</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:a20f539ef645cba235c03d8d13f221ae5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1014db39eed6f085ab79116510005e4c"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html#a1014db39eed6f085ab79116510005e4c">operator=</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:a1014db39eed6f085ab79116510005e4c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal1"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal1')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td></tr>
+<tr class="memitem:aba62d8d0b9591bcfd728f8ae8a22d600 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#aba62d8d0b9591bcfd728f8ae8a22d600">signal1</a> ()</td></tr>
+<tr class="separator:aba62d8d0b9591bcfd728f8ae8a22d600 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab3378dd754ffddb4760f2a3afb271dbe inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#ab3378dd754ffddb4760f2a3afb271dbe">signal1</a> (const <a class="el" href="classsigc_1_1signal1.html">signal1</a> & src)</td></tr>
+<tr class="separator:ab3378dd754ffddb4760f2a3afb271dbe inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a85ec968e0b25ee9285f297da5416b2a4 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a85ec968e0b25ee9285f297da5416b2a4">signal1</a> (<a class="el" href="classsigc_1_1signal1.html">signal1</a> && src)</td></tr>
+<tr class="separator:a85ec968e0b25ee9285f297da5416b2a4 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aac2ade0896bd4a982777d5dd6ac75888 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#ab61e2d1fcaf903dffbb26b01800907fb">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#aac2ade0896bd4a982777d5dd6ac75888">connect</a> (const <a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:aac2ade0896bd4a982777d5dd6ac75888 inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal1.html#aac2ade0896bd4a982777d5dd6ac75888">More...</a><br /></td></tr>
+<tr class="separator:aac2ade0896bd4a982777d5dd6ac75888 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac69d2681c586b310d8c056a319bb65fe inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#ab61e2d1fcaf903dffbb26b01800907fb">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#ac69d2681c586b310d8c056a319bb65fe">connect</a> (<a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:ac69d2681c586b310d8c056a319bb65fe inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal1.html#ac69d2681c586b310d8c056a319bb65fe">More...</a><br /></td></tr>
+<tr class="separator:ac69d2681c586b310d8c056a319bb65fe inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:affe595f8b70b4f43a21be7192c0cba42 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:affe595f8b70b4f43a21be7192c0cba42 inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42">More...</a><br /></td></tr>
+<tr class="separator:affe595f8b70b4f43a21be7192c0cba42 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a449fc940ae822c4b6ea9282b9b292015 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a449fc940ae822c4b6ea9282b9b292015">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a449fc940ae822c4b6ea9282b9b292015 inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal1.html#a449fc940ae822c4b6ea9282b9b292015">More...</a><br /></td></tr>
+<tr class="separator:a449fc940ae822c4b6ea9282b9b292015 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87513117263fd39d5a5a86e0fb8b2a78 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html">bound_const_mem_functor1</a>< <a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a>, <a class="el" href="classsigc_1_1signal1.html">signal1</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a87513117263fd39d5a5a86e0fb8b2a78">make_slot</a> () const</td></tr>
+<tr class="memdesc:a87513117263fd39d5a5a86e0fb8b2a78 inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal1.html#a87513117263fd39d5a5a86e0fb8b2a78">More...</a><br /></td></tr>
+<tr class="separator:a87513117263fd39d5a5a86e0fb8b2a78 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a828907c11f5c18d9522e5d5139484620 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a828907c11f5c18d9522e5d5139484620">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a828907c11f5c18d9522e5d5139484620 inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal1.html#a828907c11f5c18d9522e5d5139484620">More...</a><br /></td></tr>
+<tr class="separator:a828907c11f5c18d9522e5d5139484620 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a29cd06bf91f96f11c5f29237b8afbb71 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html">signal1</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a29cd06bf91f96f11c5f29237b8afbb71">operator=</a> (const <a class="el" href="classsigc_1_1signal1.html">signal1</a> & src)</td></tr>
+<tr class="separator:a29cd06bf91f96f11c5f29237b8afbb71 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab817711d4bc93402d15e87b89a09c364 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html">signal1</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#ab817711d4bc93402d15e87b89a09c364">operator=</a> (<a class="el" href="classsigc_1_1signal1.html">signal1</a> && src)</td></tr>
+<tr class="separator:ab817711d4bc93402d15e87b89a09c364 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7653b68e6a3b8445de91f89060bf2600 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#a5fadeb350140d6aaf560b217e7e7c4b4">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a7653b68e6a3b8445de91f89060bf2600">slots</a> ()</td></tr>
+<tr class="memdesc:a7653b68e6a3b8445de91f89060bf2600 inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal1.html#a7653b68e6a3b8445de91f89060bf2600">More...</a><br /></td></tr>
+<tr class="separator:a7653b68e6a3b8445de91f89060bf2600 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7777660b21fef2a6941c7dff23964604 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal1.html#a5fadeb350140d6aaf560b217e7e7c4b4">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a7777660b21fef2a6941c7dff23964604">slots</a> () const</td></tr>
+<tr class="memdesc:a7777660b21fef2a6941c7dff23964604 inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal1.html#a7777660b21fef2a6941c7dff23964604">More...</a><br /></td></tr>
+<tr class="separator:a7777660b21fef2a6941c7dff23964604 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal1"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal1')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, nil ></a></td></tr>
+<tr class="memitem:af1e262b35c9574e65b2607cdfcaad707 inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#af1e262b35c9574e65b2607cdfcaad707">const_iterator</a></td></tr>
+<tr class="separator:af1e262b35c9574e65b2607cdfcaad707 inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aeb327519f808dfec9a723511ef82caa3 inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#aeb327519f808dfec9a723511ef82caa3">const_reverse_iterator</a></td></tr>
+<tr class="separator:aeb327519f808dfec9a723511ef82caa3 inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a63c6e2b55c8c3af083402bb7f5a66593 inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit1< T_return, T_arg1, <a class="el" href="structsigc_1_1nil.html">nil</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a63c6e2b55c8c3af083402bb7f5a66593">emitter_type</a></td></tr>
+<tr class="separator:a63c6e2b55c8c3af083402bb7f5a66593 inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab61e2d1fcaf903dffbb26b01800907fb inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#ab61e2d1fcaf903dffbb26b01800907fb">iterator</a></td></tr>
+<tr class="separator:ab61e2d1fcaf903dffbb26b01800907fb inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adcdcfa50d60e1832ce038a4a5554fce1 inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a></td></tr>
+<tr class="separator:adcdcfa50d60e1832ce038a4a5554fce1 inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0443049aa736d88770d0f534600b2bc inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#ab0443049aa736d88770d0f534600b2bc">reverse_iterator</a></td></tr>
+<tr class="separator:ab0443049aa736d88770d0f534600b2bc inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5fadeb350140d6aaf560b217e7e7c4b4 inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a5fadeb350140d6aaf560b217e7e7c4b4">slot_list_type</a></td></tr>
+<tr class="separator:a5fadeb350140d6aaf560b217e7e7c4b4 inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a310736e1415c2cf4578892ffff35915c inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a></td></tr>
+<tr class="separator:a310736e1415c2cf4578892ffff35915c inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1><br />
+class sigc::signal< T_return(T_arg1)></h3>
+
+<p>This specialization allow use of the sigc::signal<R(Args...)> syntax,. </p>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a2e6e6d55741d1ef7e4ef3cf1a385ccf1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2e6e6d55741d1ef7e4ef3cf1a385ccf1">◆ </a></span>signal() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1)>::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a41a5c99993530756404583e4fbc748ba"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a41a5c99993530756404583e4fbc748ba">◆ </a></span>signal() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1)>::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return(T_arg1)> & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="acc30f0949e699fbff85d341162298761"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#acc30f0949e699fbff85d341162298761">◆ </a></span>signal() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1)>::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return(T_arg1)> && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a20f539ef645cba235c03d8d13f221ae5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a20f539ef645cba235c03d8d13f221ae5">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1)>::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return(T_arg1)> & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a1014db39eed6f085ab79116510005e4c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1014db39eed6f085ab79116510005e4c">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1)>::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return(T_arg1)> && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html">signal< T_return(T_arg1)></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return(T_arg1)>::accumulated< T_accumulator > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html">sigc::signal< T_return(T_arg1)>::accumulated< T_accumulator ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html#a31b87e65e2e6be201c18ff7c7c3e87e9">accumulated</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html">sigc::signal< T_return(T_arg1)>::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html#abbb5481dc26b9efce3b8604eb0f6ea27">accumulated</a>(const accumulated & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html">sigc::signal< T_return(T_arg1)>::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#aac2ade0896bd4a982777d5dd6ac75888">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#ac69d2681c586b310d8c056a319bb65fe">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#af1e262b35c9574e65b2607cdfcaad707">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#aeb327519f808dfec9a723511ef82caa3">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42">emit</a>(type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a449fc940ae822c4b6ea9282b9b292015">emit_reverse</a>(type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a63c6e2b55c8c3af083402bb7f5a66593">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#ab61e2d1fcaf903dffbb26b01800907fb">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a87513117263fd39d5a5a86e0fb8b2a78">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a828907c11f5c18d9522e5d5139484620">operator()</a>(type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a29cd06bf91f96f11c5f29237b8afbb71">operator=</a>(const signal1 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#ab817711d4bc93402d15e87b89a09c364">operator=</a>(signal1 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#ab0443049aa736d88770d0f534600b2bc">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#aba62d8d0b9591bcfd728f8ae8a22d600">signal1</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#ab3378dd754ffddb4760f2a3afb271dbe">signal1</a>(const signal1 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a85ec968e0b25ee9285f297da5416b2a4">signal1</a>(signal1 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a5fadeb350140d6aaf560b217e7e7c4b4">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a7653b68e6a3b8445de91f89060bf2600">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal1.html#a7777660b21fef2a6941c7dff23964604">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return(T_arg1)>::accumulated< T_accumulator > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html">signal< T_return(T_arg1)></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return(T_arg1)>::accumulated< T_accumulator > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal1.html" title="Signal declaration.">sigc::signal1</a> template.
+ <a href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return(T_arg1)>::accumulated< T_accumulator >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated__inherit__graph.png" border="0" usemap="#asigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" id="asigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::signal1 template." alt="" coords="11,244,189,300"/>
+<area shape="rect" href="classsigc_1_1signal1.html" title=" " alt="" coords="5,155,195,196"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="33,80,167,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="42,5,158,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a31b87e65e2e6be201c18ff7c7c3e87e9"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html#a31b87e65e2e6be201c18ff7c7c3e87e9">accumulated</a> ()</td></tr>
+<tr class="separator:a31b87e65e2e6be201c18ff7c7c3e87e9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abbb5481dc26b9efce3b8604eb0f6ea27"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html#abbb5481dc26b9efce3b8604eb0f6ea27">accumulated</a> (const accumulated & src)</td></tr>
+<tr class="separator:abbb5481dc26b9efce3b8604eb0f6ea27"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal1"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal1')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td></tr>
+<tr class="memitem:aba62d8d0b9591bcfd728f8ae8a22d600 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#aba62d8d0b9591bcfd728f8ae8a22d600">signal1</a> ()</td></tr>
+<tr class="separator:aba62d8d0b9591bcfd728f8ae8a22d600 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab3378dd754ffddb4760f2a3afb271dbe inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#ab3378dd754ffddb4760f2a3afb271dbe">signal1</a> (const <a class="el" href="classsigc_1_1signal1.html">signal1</a> & src)</td></tr>
+<tr class="separator:ab3378dd754ffddb4760f2a3afb271dbe inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a85ec968e0b25ee9285f297da5416b2a4 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a85ec968e0b25ee9285f297da5416b2a4">signal1</a> (<a class="el" href="classsigc_1_1signal1.html">signal1</a> && src)</td></tr>
+<tr class="separator:a85ec968e0b25ee9285f297da5416b2a4 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aac2ade0896bd4a982777d5dd6ac75888 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#ab61e2d1fcaf903dffbb26b01800907fb">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#aac2ade0896bd4a982777d5dd6ac75888">connect</a> (const <a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:aac2ade0896bd4a982777d5dd6ac75888 inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal1.html#aac2ade0896bd4a982777d5dd6ac75888">More...</a><br /></td></tr>
+<tr class="separator:aac2ade0896bd4a982777d5dd6ac75888 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac69d2681c586b310d8c056a319bb65fe inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#ab61e2d1fcaf903dffbb26b01800907fb">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#ac69d2681c586b310d8c056a319bb65fe">connect</a> (<a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:ac69d2681c586b310d8c056a319bb65fe inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal1.html#ac69d2681c586b310d8c056a319bb65fe">More...</a><br /></td></tr>
+<tr class="separator:ac69d2681c586b310d8c056a319bb65fe inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:affe595f8b70b4f43a21be7192c0cba42 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42">emit</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:affe595f8b70b4f43a21be7192c0cba42 inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42">More...</a><br /></td></tr>
+<tr class="separator:affe595f8b70b4f43a21be7192c0cba42 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a449fc940ae822c4b6ea9282b9b292015 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a449fc940ae822c4b6ea9282b9b292015">emit_reverse</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a449fc940ae822c4b6ea9282b9b292015 inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal1.html#a449fc940ae822c4b6ea9282b9b292015">More...</a><br /></td></tr>
+<tr class="separator:a449fc940ae822c4b6ea9282b9b292015 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87513117263fd39d5a5a86e0fb8b2a78 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html">bound_const_mem_functor1</a>< <a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a>, <a class="el" href="classsigc_1_1signal1.html">signal1</a>, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a87513117263fd39d5a5a86e0fb8b2a78">make_slot</a> () const</td></tr>
+<tr class="memdesc:a87513117263fd39d5a5a86e0fb8b2a78 inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal1.html#a87513117263fd39d5a5a86e0fb8b2a78">More...</a><br /></td></tr>
+<tr class="separator:a87513117263fd39d5a5a86e0fb8b2a78 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a828907c11f5c18d9522e5d5139484620 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a828907c11f5c18d9522e5d5139484620">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a828907c11f5c18d9522e5d5139484620 inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal1.html#a828907c11f5c18d9522e5d5139484620">More...</a><br /></td></tr>
+<tr class="separator:a828907c11f5c18d9522e5d5139484620 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a29cd06bf91f96f11c5f29237b8afbb71 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html">signal1</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a29cd06bf91f96f11c5f29237b8afbb71">operator=</a> (const <a class="el" href="classsigc_1_1signal1.html">signal1</a> & src)</td></tr>
+<tr class="separator:a29cd06bf91f96f11c5f29237b8afbb71 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab817711d4bc93402d15e87b89a09c364 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html">signal1</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#ab817711d4bc93402d15e87b89a09c364">operator=</a> (<a class="el" href="classsigc_1_1signal1.html">signal1</a> && src)</td></tr>
+<tr class="separator:ab817711d4bc93402d15e87b89a09c364 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7653b68e6a3b8445de91f89060bf2600 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal1.html#a5fadeb350140d6aaf560b217e7e7c4b4">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a7653b68e6a3b8445de91f89060bf2600">slots</a> ()</td></tr>
+<tr class="memdesc:a7653b68e6a3b8445de91f89060bf2600 inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal1.html#a7653b68e6a3b8445de91f89060bf2600">More...</a><br /></td></tr>
+<tr class="separator:a7653b68e6a3b8445de91f89060bf2600 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7777660b21fef2a6941c7dff23964604 inherit pub_methods_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal1.html#a5fadeb350140d6aaf560b217e7e7c4b4">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a7777660b21fef2a6941c7dff23964604">slots</a> () const</td></tr>
+<tr class="memdesc:a7777660b21fef2a6941c7dff23964604 inherit pub_methods_classsigc_1_1signal1"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal1.html#a7777660b21fef2a6941c7dff23964604">More...</a><br /></td></tr>
+<tr class="separator:a7777660b21fef2a6941c7dff23964604 inherit pub_methods_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal1"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal1')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td></tr>
+<tr class="memitem:af1e262b35c9574e65b2607cdfcaad707 inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#af1e262b35c9574e65b2607cdfcaad707">const_iterator</a></td></tr>
+<tr class="separator:af1e262b35c9574e65b2607cdfcaad707 inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aeb327519f808dfec9a723511ef82caa3 inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#aeb327519f808dfec9a723511ef82caa3">const_reverse_iterator</a></td></tr>
+<tr class="separator:aeb327519f808dfec9a723511ef82caa3 inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a63c6e2b55c8c3af083402bb7f5a66593 inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit1< T_return, T_arg1, T_accumulator > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a63c6e2b55c8c3af083402bb7f5a66593">emitter_type</a></td></tr>
+<tr class="separator:a63c6e2b55c8c3af083402bb7f5a66593 inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab61e2d1fcaf903dffbb26b01800907fb inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#ab61e2d1fcaf903dffbb26b01800907fb">iterator</a></td></tr>
+<tr class="separator:ab61e2d1fcaf903dffbb26b01800907fb inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adcdcfa50d60e1832ce038a4a5554fce1 inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">result_type</a></td></tr>
+<tr class="separator:adcdcfa50d60e1832ce038a4a5554fce1 inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0443049aa736d88770d0f534600b2bc inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#ab0443049aa736d88770d0f534600b2bc">reverse_iterator</a></td></tr>
+<tr class="separator:ab0443049aa736d88770d0f534600b2bc inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5fadeb350140d6aaf560b217e7e7c4b4 inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a5fadeb350140d6aaf560b217e7e7c4b4">slot_list_type</a></td></tr>
+<tr class="separator:a5fadeb350140d6aaf560b217e7e7c4b4 inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a310736e1415c2cf4578892ffff35915c inherit pub_types_classsigc_1_1signal1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg1)> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">slot_type</a></td></tr>
+<tr class="separator:a310736e1415c2cf4578892ffff35915c inherit pub_types_classsigc_1_1signal1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1><br />
+template <class T_accumulator><br />
+class sigc::signal< T_return(T_arg1)>::accumulated< T_accumulator ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal1.html" title="Signal declaration.">sigc::signal1</a> template. </p>
+<p>Like <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> but the additional template parameter <em>T_accumulator</em> defines the accumulator type that should be used. </p>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a31b87e65e2e6be201c18ff7c7c3e87e9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a31b87e65e2e6be201c18ff7c7c3e87e9">◆ </a></span>accumulated() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1)>::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="abbb5481dc26b9efce3b8604eb0f6ea27"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abbb5481dc26b9efce3b8604eb0f6ea27">◆ </a></span>accumulated() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return(T_arg1)>::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramtype">const accumulated & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal< T_return(T_arg1)>::accumulated< T_accumulator >" name="sigc::signal< T_return(T_arg1)>::accumulated< T_accumulator >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::signal1 template." alt="" coords="11,244,189,300"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal1.html" title=" " alt="" coords="5,155,195,196"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="33,80,167,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="42,5,158,32"/>
+</map>
--- /dev/null
+3b36fc98403212b6d5f6871ce4c7859a
\ No newline at end of file
--- /dev/null
+<map id="sigc::signal< T_return(T_arg1)>" name="sigc::signal< T_return(T_arg1)>">
+<area shape="rect" id="node1" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="11,244,175,285"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal1.html" title=" " alt="" coords="5,155,181,196"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="27,80,160,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="35,5,151,32"/>
+</map>
--- /dev/null
+aa32b46d6d28d95e00bd8fec622784ce
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4.html">signal< T_return()></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return()> Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4.html">sigc::signal< T_return()></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a609b1e0770f47c9081a3de56b65314d2">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a9b78954271b6dba5e926bd960f3e7905">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ad4f7c62954f5c270e115d9b2a2df15ea">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a476f559a69eef5999c99cd6262a9aa2f">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8">emit</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#abdae39f9a7abd6133c03d65224c227d6">emit_reverse</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ac7eafdced2d325d6003327b4360bc2dd">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ad61e875748cf4e1c2a6d89a930ae093e">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a3295536428e5e0d6478ac10e2daff736">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a2dd3042c0681542ed6f2de5840f713a1">operator()</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4.html#acbc101f4d7b4e460929593bac336957f">operator=</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4.html">sigc::signal< T_return()></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4.html#a8dd6b8bd581d87858007484d62347484">operator=</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4.html">sigc::signal< T_return()></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a4e8311eac2fd7f8ecd10bff8225ed9e3">signal0< T_return, nil >::operator=</a>(const signal0 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a693aa3743236012416349bfac56d31b6">signal0< T_return, nil >::operator=</a>(signal0 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a1d9c390974304392ed12ee81543ab997">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4.html#aefdfdd54adc65612b58929298274453c">signal</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4.html">sigc::signal< T_return()></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4.html#aba571147db7b805fad8da3c0c82fea0b">signal</a>(const signal & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4.html">sigc::signal< T_return()></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4.html#a2656448f8eb3cf4d9043009f56b08104">signal</a>(signal && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4.html">sigc::signal< T_return()></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a2fb24e11a8f645e5122646ea2b4a5d2f">signal0</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a7dc687f1afb4088a3d888aa05dbf56d9">signal0</a>(const signal0 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ac1b915a86d0b75fd4e90c2a92f7ebc49">signal0</a>(signal0 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#add195c1c738ee8efe10294f21d258b77">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a5576113ddfd6b92a96f86072262307f9">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a73523d71edd7fb4294324e9561db6f3c">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return()> Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4.html">signal< T_return()></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#nested-classes">Classes</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_07_08_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return()> Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This specialization allow use of the sigc::signal<R(Args...)> syntax,.
+ <a href="classsigc_1_1signal_3_01T__return_07_08_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return()>:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_07_08_4__inherit__graph.png" border="0" usemap="#asigc_1_1signal_3_01T__return_07_08_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_07_08_4_inherit__map" id="asigc_1_1signal_3_01T__return_07_08_4_inherit__map">
+<area shape="rect" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="5,244,191,271"/>
+<area shape="rect" href="classsigc_1_1signal0.html" title=" " alt="" coords="10,155,186,196"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="31,80,165,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="40,5,156,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:aefdfdd54adc65612b58929298274453c"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4.html#aefdfdd54adc65612b58929298274453c">signal</a> ()</td></tr>
+<tr class="separator:aefdfdd54adc65612b58929298274453c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba571147db7b805fad8da3c0c82fea0b"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4.html#aba571147db7b805fad8da3c0c82fea0b">signal</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:aba571147db7b805fad8da3c0c82fea0b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2656448f8eb3cf4d9043009f56b08104"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4.html#a2656448f8eb3cf4d9043009f56b08104">signal</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:a2656448f8eb3cf4d9043009f56b08104"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acbc101f4d7b4e460929593bac336957f"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4.html#acbc101f4d7b4e460929593bac336957f">operator=</a> (const <a class="el" href="classsigc_1_1signal.html">signal</a> & src)</td></tr>
+<tr class="separator:acbc101f4d7b4e460929593bac336957f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8dd6b8bd581d87858007484d62347484"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal.html">signal</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4.html#a8dd6b8bd581d87858007484d62347484">operator=</a> (<a class="el" href="classsigc_1_1signal.html">signal</a> && src)</td></tr>
+<tr class="separator:a8dd6b8bd581d87858007484d62347484"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal0"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal0')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td></tr>
+<tr class="memitem:a2fb24e11a8f645e5122646ea2b4a5d2f inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a2fb24e11a8f645e5122646ea2b4a5d2f">signal0</a> ()</td></tr>
+<tr class="separator:a2fb24e11a8f645e5122646ea2b4a5d2f inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7dc687f1afb4088a3d888aa05dbf56d9 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a7dc687f1afb4088a3d888aa05dbf56d9">signal0</a> (const <a class="el" href="classsigc_1_1signal0.html">signal0</a> & src)</td></tr>
+<tr class="separator:a7dc687f1afb4088a3d888aa05dbf56d9 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac1b915a86d0b75fd4e90c2a92f7ebc49 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ac1b915a86d0b75fd4e90c2a92f7ebc49">signal0</a> (<a class="el" href="classsigc_1_1signal0.html">signal0</a> && src)</td></tr>
+<tr class="separator:ac1b915a86d0b75fd4e90c2a92f7ebc49 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a609b1e0770f47c9081a3de56b65314d2 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#ad61e875748cf4e1c2a6d89a930ae093e">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a609b1e0770f47c9081a3de56b65314d2">connect</a> (const <a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:a609b1e0770f47c9081a3de56b65314d2 inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal0.html#a609b1e0770f47c9081a3de56b65314d2">More...</a><br /></td></tr>
+<tr class="separator:a609b1e0770f47c9081a3de56b65314d2 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9b78954271b6dba5e926bd960f3e7905 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#ad61e875748cf4e1c2a6d89a930ae093e">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a9b78954271b6dba5e926bd960f3e7905">connect</a> (<a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:a9b78954271b6dba5e926bd960f3e7905 inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal0.html#a9b78954271b6dba5e926bd960f3e7905">More...</a><br /></td></tr>
+<tr class="separator:a9b78954271b6dba5e926bd960f3e7905 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a655829125186645bcbc61db8252134a8 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8">emit</a> () const</td></tr>
+<tr class="memdesc:a655829125186645bcbc61db8252134a8 inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8">More...</a><br /></td></tr>
+<tr class="separator:a655829125186645bcbc61db8252134a8 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abdae39f9a7abd6133c03d65224c227d6 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#abdae39f9a7abd6133c03d65224c227d6">emit_reverse</a> () const</td></tr>
+<tr class="memdesc:abdae39f9a7abd6133c03d65224c227d6 inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal0.html#abdae39f9a7abd6133c03d65224c227d6">More...</a><br /></td></tr>
+<tr class="separator:abdae39f9a7abd6133c03d65224c227d6 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3295536428e5e0d6478ac10e2daff736 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html">bound_const_mem_functor0</a>< <a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a>, <a class="el" href="classsigc_1_1signal0.html">signal0</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a3295536428e5e0d6478ac10e2daff736">make_slot</a> () const</td></tr>
+<tr class="memdesc:a3295536428e5e0d6478ac10e2daff736 inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal0.html#a3295536428e5e0d6478ac10e2daff736">More...</a><br /></td></tr>
+<tr class="separator:a3295536428e5e0d6478ac10e2daff736 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2dd3042c0681542ed6f2de5840f713a1 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a2dd3042c0681542ed6f2de5840f713a1">operator()</a> () const</td></tr>
+<tr class="memdesc:a2dd3042c0681542ed6f2de5840f713a1 inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal0.html#a2dd3042c0681542ed6f2de5840f713a1">More...</a><br /></td></tr>
+<tr class="separator:a2dd3042c0681542ed6f2de5840f713a1 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4e8311eac2fd7f8ecd10bff8225ed9e3 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html">signal0</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a4e8311eac2fd7f8ecd10bff8225ed9e3">operator=</a> (const <a class="el" href="classsigc_1_1signal0.html">signal0</a> & src)</td></tr>
+<tr class="separator:a4e8311eac2fd7f8ecd10bff8225ed9e3 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a693aa3743236012416349bfac56d31b6 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html">signal0</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a693aa3743236012416349bfac56d31b6">operator=</a> (<a class="el" href="classsigc_1_1signal0.html">signal0</a> && src)</td></tr>
+<tr class="separator:a693aa3743236012416349bfac56d31b6 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5576113ddfd6b92a96f86072262307f9 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#add195c1c738ee8efe10294f21d258b77">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a5576113ddfd6b92a96f86072262307f9">slots</a> ()</td></tr>
+<tr class="memdesc:a5576113ddfd6b92a96f86072262307f9 inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal0.html#a5576113ddfd6b92a96f86072262307f9">More...</a><br /></td></tr>
+<tr class="separator:a5576113ddfd6b92a96f86072262307f9 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a73523d71edd7fb4294324e9561db6f3c inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal0.html#add195c1c738ee8efe10294f21d258b77">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a73523d71edd7fb4294324e9561db6f3c">slots</a> () const</td></tr>
+<tr class="memdesc:a73523d71edd7fb4294324e9561db6f3c inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal0.html#a73523d71edd7fb4294324e9561db6f3c">More...</a><br /></td></tr>
+<tr class="separator:a73523d71edd7fb4294324e9561db6f3c inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal0"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal0')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, nil ></a></td></tr>
+<tr class="memitem:ad4f7c62954f5c270e115d9b2a2df15ea inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ad4f7c62954f5c270e115d9b2a2df15ea">const_iterator</a></td></tr>
+<tr class="separator:ad4f7c62954f5c270e115d9b2a2df15ea inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a476f559a69eef5999c99cd6262a9aa2f inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a476f559a69eef5999c99cd6262a9aa2f">const_reverse_iterator</a></td></tr>
+<tr class="separator:a476f559a69eef5999c99cd6262a9aa2f inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac7eafdced2d325d6003327b4360bc2dd inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit0< T_return, <a class="el" href="structsigc_1_1nil.html">nil</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ac7eafdced2d325d6003327b4360bc2dd">emitter_type</a></td></tr>
+<tr class="separator:ac7eafdced2d325d6003327b4360bc2dd inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad61e875748cf4e1c2a6d89a930ae093e inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ad61e875748cf4e1c2a6d89a930ae093e">iterator</a></td></tr>
+<tr class="separator:ad61e875748cf4e1c2a6d89a930ae093e inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae291a90c83f8ad1cdcc7c2a4cdd958de inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a></td></tr>
+<tr class="separator:ae291a90c83f8ad1cdcc7c2a4cdd958de inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1d9c390974304392ed12ee81543ab997 inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a1d9c390974304392ed12ee81543ab997">reverse_iterator</a></td></tr>
+<tr class="separator:a1d9c390974304392ed12ee81543ab997 inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:add195c1c738ee8efe10294f21d258b77 inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#add195c1c738ee8efe10294f21d258b77">slot_list_type</a></td></tr>
+<tr class="separator:add195c1c738ee8efe10294f21d258b77 inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae3fc90cec344b6585979e77d2b359287 inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return()> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a></td></tr>
+<tr class="separator:ae3fc90cec344b6585979e77d2b359287 inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return><br />
+class sigc::signal< T_return()></h3>
+
+<p>This specialization allow use of the sigc::signal<R(Args...)> syntax,. </p>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="aefdfdd54adc65612b58929298274453c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aefdfdd54adc65612b58929298274453c">◆ </a></span>signal() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return()>::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aba571147db7b805fad8da3c0c82fea0b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aba571147db7b805fad8da3c0c82fea0b">◆ </a></span>signal() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return()>::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return()> & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a2656448f8eb3cf4d9043009f56b08104"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2656448f8eb3cf4d9043009f56b08104">◆ </a></span>signal() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return()>::<a class="el" href="classsigc_1_1signal.html">signal</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return()> && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="acbc101f4d7b4e460929593bac336957f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#acbc101f4d7b4e460929593bac336957f">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return()>::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1signal.html">signal</a>< T_return()> & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a8dd6b8bd581d87858007484d62347484"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8dd6b8bd581d87858007484d62347484">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">signal</a>& <a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return()>::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1signal.html">signal</a>< T_return()> && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4.html">signal< T_return()></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return()>::accumulated< T_accumulator > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html">sigc::signal< T_return()>::accumulated< T_accumulator ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html#a601feadb67ac4aaa7af709af51f654ca">accumulated</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html">sigc::signal< T_return()>::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html#a219dd919cd64e95ad89c5a501b3abcf6">accumulated</a>(const accumulated & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html">sigc::signal< T_return()>::accumulated< T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a609b1e0770f47c9081a3de56b65314d2">connect</a>(const slot_type & slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a9b78954271b6dba5e926bd960f3e7905">connect</a>(slot_type && slot_)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base::connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ad4f7c62954f5c270e115d9b2a2df15ea">const_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a476f559a69eef5999c99cd6262a9aa2f">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8">emit</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#abdae39f9a7abd6133c03d65224c227d6">emit_reverse</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ac7eafdced2d325d6003327b4360bc2dd">emitter_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ad61e875748cf4e1c2a6d89a930ae093e">iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a3295536428e5e0d6478ac10e2daff736">make_slot</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a2dd3042c0681542ed6f2de5840f713a1">operator()</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a4e8311eac2fd7f8ecd10bff8225ed9e3">operator=</a>(const signal0 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a693aa3743236012416349bfac56d31b6">operator=</a>(signal0 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base::operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base::operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a1d9c390974304392ed12ee81543ab997">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a2fb24e11a8f645e5122646ea2b4a5d2f">signal0</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a7dc687f1afb4088a3d888aa05dbf56d9">signal0</a>(const signal0 & src)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ac1b915a86d0b75fd4e90c2a92f7ebc49">signal0</a>(signal0 && src)</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#add195c1c738ee8efe10294f21d258b77">slot_list_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a5576113ddfd6b92a96f86072262307f9">slots</a>()</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1signal0.html#a73523d71edd7fb4294324e9561db6f3c">slots</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal< T_return()>::accumulated< T_accumulator > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4.html">signal< T_return()></a></li><li class="navelem"><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html">accumulated</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal< T_return()>::accumulated< T_accumulator > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal0.html" title="Signal declaration.">sigc::signal0</a> template.
+ <a href="classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal< T_return()>::accumulated< T_accumulator >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated__inherit__graph.png" border="0" usemap="#asigc_1_1signal_3_01T__return_07_08_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal_3_01T__return_07_08_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map" id="asigc_1_1signal_3_01T__return_07_08_4_1_1accumulated_3_01T__accumulator_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::signal0 template." alt="" coords="5,244,267,285"/>
+<area shape="rect" href="classsigc_1_1signal0.html" title=" " alt="" coords="48,155,224,196"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="69,80,203,107"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="78,5,194,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a601feadb67ac4aaa7af709af51f654ca"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html#a601feadb67ac4aaa7af709af51f654ca">accumulated</a> ()</td></tr>
+<tr class="separator:a601feadb67ac4aaa7af709af51f654ca"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a219dd919cd64e95ad89c5a501b3abcf6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html#a219dd919cd64e95ad89c5a501b3abcf6">accumulated</a> (const accumulated & src)</td></tr>
+<tr class="separator:a219dd919cd64e95ad89c5a501b3abcf6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1signal0"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1signal0')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td></tr>
+<tr class="memitem:a2fb24e11a8f645e5122646ea2b4a5d2f inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a2fb24e11a8f645e5122646ea2b4a5d2f">signal0</a> ()</td></tr>
+<tr class="separator:a2fb24e11a8f645e5122646ea2b4a5d2f inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7dc687f1afb4088a3d888aa05dbf56d9 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a7dc687f1afb4088a3d888aa05dbf56d9">signal0</a> (const <a class="el" href="classsigc_1_1signal0.html">signal0</a> & src)</td></tr>
+<tr class="separator:a7dc687f1afb4088a3d888aa05dbf56d9 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac1b915a86d0b75fd4e90c2a92f7ebc49 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ac1b915a86d0b75fd4e90c2a92f7ebc49">signal0</a> (<a class="el" href="classsigc_1_1signal0.html">signal0</a> && src)</td></tr>
+<tr class="separator:ac1b915a86d0b75fd4e90c2a92f7ebc49 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a609b1e0770f47c9081a3de56b65314d2 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#ad61e875748cf4e1c2a6d89a930ae093e">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a609b1e0770f47c9081a3de56b65314d2">connect</a> (const <a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a> & slot_)</td></tr>
+<tr class="memdesc:a609b1e0770f47c9081a3de56b65314d2 inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal0.html#a609b1e0770f47c9081a3de56b65314d2">More...</a><br /></td></tr>
+<tr class="separator:a609b1e0770f47c9081a3de56b65314d2 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9b78954271b6dba5e926bd960f3e7905 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#ad61e875748cf4e1c2a6d89a930ae093e">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a9b78954271b6dba5e926bd960f3e7905">connect</a> (<a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a> && slot_)</td></tr>
+<tr class="memdesc:a9b78954271b6dba5e926bd960f3e7905 inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Add a slot to the list of slots. <a href="classsigc_1_1signal0.html#a9b78954271b6dba5e926bd960f3e7905">More...</a><br /></td></tr>
+<tr class="separator:a9b78954271b6dba5e926bd960f3e7905 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a655829125186645bcbc61db8252134a8 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8">emit</a> () const</td></tr>
+<tr class="memdesc:a655829125186645bcbc61db8252134a8 inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal. <a href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8">More...</a><br /></td></tr>
+<tr class="separator:a655829125186645bcbc61db8252134a8 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abdae39f9a7abd6133c03d65224c227d6 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#abdae39f9a7abd6133c03d65224c227d6">emit_reverse</a> () const</td></tr>
+<tr class="memdesc:abdae39f9a7abd6133c03d65224c227d6 inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal in reverse order (see <a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal0.html#abdae39f9a7abd6133c03d65224c227d6">More...</a><br /></td></tr>
+<tr class="separator:abdae39f9a7abd6133c03d65224c227d6 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3295536428e5e0d6478ac10e2daff736 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html">bound_const_mem_functor0</a>< <a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a>, <a class="el" href="classsigc_1_1signal0.html">signal0</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a3295536428e5e0d6478ac10e2daff736">make_slot</a> () const</td></tr>
+<tr class="memdesc:a3295536428e5e0d6478ac10e2daff736 inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor that calls <a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8" title="Triggers the emission of the signal.">emit()</a> on this signal. <a href="classsigc_1_1signal0.html#a3295536428e5e0d6478ac10e2daff736">More...</a><br /></td></tr>
+<tr class="separator:a3295536428e5e0d6478ac10e2daff736 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2dd3042c0681542ed6f2de5840f713a1 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a2dd3042c0681542ed6f2de5840f713a1">operator()</a> () const</td></tr>
+<tr class="memdesc:a2dd3042c0681542ed6f2de5840f713a1 inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Triggers the emission of the signal (see <a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8" title="Triggers the emission of the signal.">emit()</a>). <a href="classsigc_1_1signal0.html#a2dd3042c0681542ed6f2de5840f713a1">More...</a><br /></td></tr>
+<tr class="separator:a2dd3042c0681542ed6f2de5840f713a1 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4e8311eac2fd7f8ecd10bff8225ed9e3 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html">signal0</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a4e8311eac2fd7f8ecd10bff8225ed9e3">operator=</a> (const <a class="el" href="classsigc_1_1signal0.html">signal0</a> & src)</td></tr>
+<tr class="separator:a4e8311eac2fd7f8ecd10bff8225ed9e3 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a693aa3743236012416349bfac56d31b6 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html">signal0</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a693aa3743236012416349bfac56d31b6">operator=</a> (<a class="el" href="classsigc_1_1signal0.html">signal0</a> && src)</td></tr>
+<tr class="separator:a693aa3743236012416349bfac56d31b6 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5576113ddfd6b92a96f86072262307f9 inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1signal0.html#add195c1c738ee8efe10294f21d258b77">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a5576113ddfd6b92a96f86072262307f9">slots</a> ()</td></tr>
+<tr class="memdesc:a5576113ddfd6b92a96f86072262307f9 inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal0.html#a5576113ddfd6b92a96f86072262307f9">More...</a><br /></td></tr>
+<tr class="separator:a5576113ddfd6b92a96f86072262307f9 inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a73523d71edd7fb4294324e9561db6f3c inherit pub_methods_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="classsigc_1_1signal0.html#add195c1c738ee8efe10294f21d258b77">slot_list_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a73523d71edd7fb4294324e9561db6f3c">slots</a> () const</td></tr>
+<tr class="memdesc:a73523d71edd7fb4294324e9561db6f3c inherit pub_methods_classsigc_1_1signal0"><td class="mdescLeft"> </td><td class="mdescRight">Creates an STL-style interface for the signal's list of slots. <a href="classsigc_1_1signal0.html#a73523d71edd7fb4294324e9561db6f3c">More...</a><br /></td></tr>
+<tr class="separator:a73523d71edd7fb4294324e9561db6f3c inherit pub_methods_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8 inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f inherit pub_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1signal0"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1signal0')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td></tr>
+<tr class="memitem:ad4f7c62954f5c270e115d9b2a2df15ea inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">slot_list_type::const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ad4f7c62954f5c270e115d9b2a2df15ea">const_iterator</a></td></tr>
+<tr class="separator:ad4f7c62954f5c270e115d9b2a2df15ea inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a476f559a69eef5999c99cd6262a9aa2f inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">slot_list_type::const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a476f559a69eef5999c99cd6262a9aa2f">const_reverse_iterator</a></td></tr>
+<tr class="separator:a476f559a69eef5999c99cd6262a9aa2f inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac7eafdced2d325d6003327b4360bc2dd inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef internal::signal_emit0< T_return, T_accumulator > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ac7eafdced2d325d6003327b4360bc2dd">emitter_type</a></td></tr>
+<tr class="separator:ac7eafdced2d325d6003327b4360bc2dd inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad61e875748cf4e1c2a6d89a930ae093e inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">slot_list_type::iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ad61e875748cf4e1c2a6d89a930ae093e">iterator</a></td></tr>
+<tr class="separator:ad61e875748cf4e1c2a6d89a930ae093e inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae291a90c83f8ad1cdcc7c2a4cdd958de inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef emitter_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">result_type</a></td></tr>
+<tr class="separator:ae291a90c83f8ad1cdcc7c2a4cdd958de inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1d9c390974304392ed12ee81543ab997 inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">slot_list_type::reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#a1d9c390974304392ed12ee81543ab997">reverse_iterator</a></td></tr>
+<tr class="separator:a1d9c390974304392ed12ee81543ab997 inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:add195c1c738ee8efe10294f21d258b77 inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html">slot_list</a>< <a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#add195c1c738ee8efe10294f21d258b77">slot_list_type</a></td></tr>
+<tr class="separator:add195c1c738ee8efe10294f21d258b77 inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae3fc90cec344b6585979e77d2b359287 inherit pub_types_classsigc_1_1signal0"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return()> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">slot_type</a></td></tr>
+<tr class="separator:ae3fc90cec344b6585979e77d2b359287 inherit pub_types_classsigc_1_1signal0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4 inherit pub_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_types_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_types_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Types inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981 inherit pro_types_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_methods_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Member Functions inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687 inherit pro_methods_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pro_attribs_structsigc_1_1signal__base"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_structsigc_1_1signal__base')"><img src="closed.png" alt="-"/> Protected Attributes inherited from <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a inherit pro_attribs_structsigc_1_1signal__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return><br />
+template <class T_accumulator><br />
+class sigc::signal< T_return()>::accumulated< T_accumulator ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal0.html" title="Signal declaration.">sigc::signal0</a> template. </p>
+<p>Like <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> but the additional template parameter <em>T_accumulator</em> defines the accumulator type that should be used. </p>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a601feadb67ac4aaa7af709af51f654ca"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a601feadb67ac4aaa7af709af51f654ca">◆ </a></span>accumulated() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return()>::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a219dd919cd64e95ad89c5a501b3abcf6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a219dd919cd64e95ad89c5a501b3abcf6">◆ </a></span>accumulated() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<div class="memtemplate">
+template <class T_accumulator > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1signal.html">sigc::signal</a>< T_return()>::accumulated< T_accumulator >::accumulated </td>
+ <td>(</td>
+ <td class="paramtype">const accumulated & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal< T_return()>::accumulated< T_accumulator >" name="sigc::signal< T_return()>::accumulated< T_accumulator >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::signal0 template." alt="" coords="5,244,267,285"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal0.html" title=" " alt="" coords="48,155,224,196"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="69,80,203,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="78,5,194,32"/>
+</map>
--- /dev/null
+0d388c7920b8265b5e675cdcb30600d5
\ No newline at end of file
--- /dev/null
+<map id="sigc::signal< T_return()>" name="sigc::signal< T_return()>">
+<area shape="rect" id="node1" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="5,244,191,271"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal0.html" title=" " alt="" coords="10,155,186,196"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="31,80,165,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="40,5,156,32"/>
+</map>
--- /dev/null
+b1bfdff1af225e40c51f5759d40393b0
\ No newline at end of file
--- /dev/null
+<map id="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >" name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::signal# templates." alt="" coords="5,259,184,329"/>
+<area shape="rect" id="node2" href="$classsigc_1_1signal7.html" title=" " alt="" coords="7,155,183,211"/>
+<area shape="rect" id="node3" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="28,80,161,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="37,5,153,32"/>
+</map>
--- /dev/null
+c226d691d453a2a4cf64db8ffd0f4403
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot.html">slot</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1slot.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot7.html#a58edf93a837003d1a69fc77d39fc11a9">arg1_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot7.html#ad144d8ea3ecb891d358b5b1b969be7e2">arg2_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot7.html#af90cd5954008a84d6459d99de152a08c">arg3_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot7.html#af42bc9af248b7c2226d93230bd7b1024">arg4_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot7.html#ad6c1006a29f6fcb721bc39e8d6f82323">arg5_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot7.html#ae25a8a8663addfce52415a20725a3b3e">arg6_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot7.html#a2dc6c96b8d014fab9daea823188ca021">arg7_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d">operator()</a>(arg1_type_ _A_a1, arg2_type_ _A_a2, arg3_type_ _A_a3, arg4_type_ _A_a4, arg5_type_ _A_a5, arg6_type_ _A_a6, arg7_type_ _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot.html#ac7beb1ab973b6cd124d2cdea3f0c1e0c">operator=</a>(const slot & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot.html#a0f4ef3f59a7f7228b8b4fddabdbd6924">operator=</a>(slot && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot7.html#af6bf09a0b3c09245257af113e70269d2">slot7< T_return, nil, nil, nil, nil, nil, nil, nil >::operator=</a>(const slot7 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot7.html#a82b499c48909c51c4dad097885804638">slot7< T_return, nil, nil, nil, nil, nil, nil, nil >::operator=</a>(slot7 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">sigc::slot_base::operator=</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">sigc::slot_base::operator=</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot.html#a1966941e9654adfb3af4b994fd18a7f3">parent_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot7.html#a06a374d3304636cb48fed29542dc851f">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a>(void * parent, void *(* cleanup)(void *)) const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot.html#af643a8ef3eafd24f738224bbd6056fa3">slot</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot.html#ad790b9eb2c959f0f266dc94c0e84dd35">slot</a>(const T_functor & _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1slot.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot.html#ac53122c7f0f1f4dd9493e9ac88837ae2">slot</a>(const slot & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot.html#a445f8243e1eac20f8f925824c4acf4cf">slot</a>(slot && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot7.html#abf200ae4152fb26fc96a6863be3548b8">slot7</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot7.html#aa9b64dc6516b8a0d55f46e4737eaaf8b">slot7</a>(const T_functor & _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot7.html#a6411349bb6f8d7151f41ae7772e61f6d">slot7</a>(const slot7 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot7.html#a69a267bb61931f4ea039048d3221517c">slot7</a>(slot7 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a>(rep_type * rep) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot.html">slot</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1slot-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__slot.html">Slots</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a># templates.
+ <a href="classsigc_1_1slot.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/slot.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1slot__inherit__graph.png" border="0" usemap="#asigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map" id="asigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::slot# templates." alt="" coords="5,259,184,329"/>
+<area shape="rect" href="classsigc_1_1slot7.html" title=" " alt="" coords="14,155,175,211"/>
+<area shape="rect" href="classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="35,80,154,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="25,5,165,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a1966941e9654adfb3af4b994fd18a7f3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot7.html">slot7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot.html#a1966941e9654adfb3af4b994fd18a7f3">parent_type</a></td></tr>
+<tr class="separator:a1966941e9654adfb3af4b994fd18a7f3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1slot7"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1slot7')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td></tr>
+<tr class="memitem:a58edf93a837003d1a69fc77d39fc11a9 inherit pub_types_classsigc_1_1slot7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#a58edf93a837003d1a69fc77d39fc11a9">arg1_type_</a></td></tr>
+<tr class="separator:a58edf93a837003d1a69fc77d39fc11a9 inherit pub_types_classsigc_1_1slot7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad144d8ea3ecb891d358b5b1b969be7e2 inherit pub_types_classsigc_1_1slot7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#ad144d8ea3ecb891d358b5b1b969be7e2">arg2_type_</a></td></tr>
+<tr class="separator:ad144d8ea3ecb891d358b5b1b969be7e2 inherit pub_types_classsigc_1_1slot7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af90cd5954008a84d6459d99de152a08c inherit pub_types_classsigc_1_1slot7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#af90cd5954008a84d6459d99de152a08c">arg3_type_</a></td></tr>
+<tr class="separator:af90cd5954008a84d6459d99de152a08c inherit pub_types_classsigc_1_1slot7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af42bc9af248b7c2226d93230bd7b1024 inherit pub_types_classsigc_1_1slot7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#af42bc9af248b7c2226d93230bd7b1024">arg4_type_</a></td></tr>
+<tr class="separator:af42bc9af248b7c2226d93230bd7b1024 inherit pub_types_classsigc_1_1slot7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad6c1006a29f6fcb721bc39e8d6f82323 inherit pub_types_classsigc_1_1slot7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#ad6c1006a29f6fcb721bc39e8d6f82323">arg5_type_</a></td></tr>
+<tr class="separator:ad6c1006a29f6fcb721bc39e8d6f82323 inherit pub_types_classsigc_1_1slot7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae25a8a8663addfce52415a20725a3b3e inherit pub_types_classsigc_1_1slot7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#ae25a8a8663addfce52415a20725a3b3e">arg6_type_</a></td></tr>
+<tr class="separator:ae25a8a8663addfce52415a20725a3b3e inherit pub_types_classsigc_1_1slot7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2dc6c96b8d014fab9daea823188ca021 inherit pub_types_classsigc_1_1slot7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< <a class="el" href="structsigc_1_1nil.html">nil</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#a2dc6c96b8d014fab9daea823188ca021">arg7_type_</a></td></tr>
+<tr class="separator:a2dc6c96b8d014fab9daea823188ca021 inherit pub_types_classsigc_1_1slot7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a06a374d3304636cb48fed29542dc851f inherit pub_types_classsigc_1_1slot7"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#a06a374d3304636cb48fed29542dc851f">result_type</a></td></tr>
+<tr class="separator:a06a374d3304636cb48fed29542dc851f inherit pub_types_classsigc_1_1slot7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">trackable::func_destroy_notify</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a></td></tr>
+<tr class="separator:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:af643a8ef3eafd24f738224bbd6056fa3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot.html#af643a8ef3eafd24f738224bbd6056fa3">slot</a> ()</td></tr>
+<tr class="separator:af643a8ef3eafd24f738224bbd6056fa3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac53122c7f0f1f4dd9493e9ac88837ae2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot.html#ac53122c7f0f1f4dd9493e9ac88837ae2">slot</a> (const <a class="el" href="classsigc_1_1slot.html">slot</a> & src)</td></tr>
+<tr class="memdesc:ac53122c7f0f1f4dd9493e9ac88837ae2"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot.html#ac53122c7f0f1f4dd9493e9ac88837ae2">More...</a><br /></td></tr>
+<tr class="separator:ac53122c7f0f1f4dd9493e9ac88837ae2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad790b9eb2c959f0f266dc94c0e84dd35"><td class="memTemplParams" colspan="2">template<class T_functor > </td></tr>
+<tr class="memitem:ad790b9eb2c959f0f266dc94c0e84dd35"><td class="memTemplItemLeft" align="right" valign="top"> </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot.html#ad790b9eb2c959f0f266dc94c0e84dd35">slot</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:ad790b9eb2c959f0f266dc94c0e84dd35"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an arbitrary functor. <a href="classsigc_1_1slot.html#ad790b9eb2c959f0f266dc94c0e84dd35">More...</a><br /></td></tr>
+<tr class="separator:ad790b9eb2c959f0f266dc94c0e84dd35"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a445f8243e1eac20f8f925824c4acf4cf"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot.html#a445f8243e1eac20f8f925824c4acf4cf">slot</a> (<a class="el" href="classsigc_1_1slot.html">slot</a> && src)</td></tr>
+<tr class="memdesc:a445f8243e1eac20f8f925824c4acf4cf"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot.html#a445f8243e1eac20f8f925824c4acf4cf">More...</a><br /></td></tr>
+<tr class="separator:a445f8243e1eac20f8f925824c4acf4cf"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac7beb1ab973b6cd124d2cdea3f0c1e0c"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot.html">slot</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot.html#ac7beb1ab973b6cd124d2cdea3f0c1e0c">operator=</a> (const <a class="el" href="classsigc_1_1slot.html">slot</a> & src)</td></tr>
+<tr class="memdesc:ac7beb1ab973b6cd124d2cdea3f0c1e0c"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot.html#ac7beb1ab973b6cd124d2cdea3f0c1e0c">More...</a><br /></td></tr>
+<tr class="separator:ac7beb1ab973b6cd124d2cdea3f0c1e0c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0f4ef3f59a7f7228b8b4fddabdbd6924"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot.html">slot</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot.html#a0f4ef3f59a7f7228b8b4fddabdbd6924">operator=</a> (<a class="el" href="classsigc_1_1slot.html">slot</a> && src)</td></tr>
+<tr class="memdesc:a0f4ef3f59a7f7228b8b4fddabdbd6924"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot.html#a0f4ef3f59a7f7228b8b4fddabdbd6924">More...</a><br /></td></tr>
+<tr class="separator:a0f4ef3f59a7f7228b8b4fddabdbd6924"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1slot7"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1slot7')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td></tr>
+<tr class="memitem:abf200ae4152fb26fc96a6863be3548b8 inherit pub_methods_classsigc_1_1slot7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#abf200ae4152fb26fc96a6863be3548b8">slot7</a> ()</td></tr>
+<tr class="separator:abf200ae4152fb26fc96a6863be3548b8 inherit pub_methods_classsigc_1_1slot7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a6411349bb6f8d7151f41ae7772e61f6d inherit pub_methods_classsigc_1_1slot7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#a6411349bb6f8d7151f41ae7772e61f6d">slot7</a> (const <a class="el" href="classsigc_1_1slot7.html">slot7</a> & src)</td></tr>
+<tr class="memdesc:a6411349bb6f8d7151f41ae7772e61f6d inherit pub_methods_classsigc_1_1slot7"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot7.html#a6411349bb6f8d7151f41ae7772e61f6d">More...</a><br /></td></tr>
+<tr class="separator:a6411349bb6f8d7151f41ae7772e61f6d inherit pub_methods_classsigc_1_1slot7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa9b64dc6516b8a0d55f46e4737eaaf8b inherit pub_methods_classsigc_1_1slot7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#aa9b64dc6516b8a0d55f46e4737eaaf8b">slot7</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:aa9b64dc6516b8a0d55f46e4737eaaf8b inherit pub_methods_classsigc_1_1slot7"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an arbitrary functor. <a href="classsigc_1_1slot7.html#aa9b64dc6516b8a0d55f46e4737eaaf8b">More...</a><br /></td></tr>
+<tr class="separator:aa9b64dc6516b8a0d55f46e4737eaaf8b inherit pub_methods_classsigc_1_1slot7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a69a267bb61931f4ea039048d3221517c inherit pub_methods_classsigc_1_1slot7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#a69a267bb61931f4ea039048d3221517c">slot7</a> (<a class="el" href="classsigc_1_1slot7.html">slot7</a> && src)</td></tr>
+<tr class="memdesc:a69a267bb61931f4ea039048d3221517c inherit pub_methods_classsigc_1_1slot7"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot7.html#a69a267bb61931f4ea039048d3221517c">More...</a><br /></td></tr>
+<tr class="separator:a69a267bb61931f4ea039048d3221517c inherit pub_methods_classsigc_1_1slot7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a28e18e1a9adc88a4758be7d2497fc88d inherit pub_methods_classsigc_1_1slot7"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d">operator()</a> (<a class="el" href="classsigc_1_1slot7.html#a58edf93a837003d1a69fc77d39fc11a9">arg1_type_</a> _A_a1, <a class="el" href="classsigc_1_1slot7.html#ad144d8ea3ecb891d358b5b1b969be7e2">arg2_type_</a> _A_a2, <a class="el" href="classsigc_1_1slot7.html#af90cd5954008a84d6459d99de152a08c">arg3_type_</a> _A_a3, <a class="el" href="classsigc_1_1slot7.html#af42bc9af248b7c2226d93230bd7b1024">arg4_type_</a> _A_a4, <a class="el" href="classsigc_1_1slot7.html#ad6c1006a29f6fcb721bc39e8d6f82323">arg5_type_</a> _A_a5, <a class="el" href="classsigc_1_1slot7.html#ae25a8a8663addfce52415a20725a3b3e">arg6_type_</a> _A_a6, <a class="el" href="classsigc_1_1slot7.html#a2dc6c96b8d014fab9daea823188ca021">arg7_type_</a> _A_a7) const</td></tr>
+<tr class="memdesc:a28e18e1a9adc88a4758be7d2497fc88d inherit pub_methods_classsigc_1_1slot7"><td class="mdescLeft"> </td><td class="mdescRight">Invoke the contained functor unless slot is in blocking state. <a href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d">More...</a><br /></td></tr>
+<tr class="separator:a28e18e1a9adc88a4758be7d2497fc88d inherit pub_methods_classsigc_1_1slot7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af6bf09a0b3c09245257af113e70269d2 inherit pub_methods_classsigc_1_1slot7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot7.html">slot7</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#af6bf09a0b3c09245257af113e70269d2">operator=</a> (const <a class="el" href="classsigc_1_1slot7.html">slot7</a> & src)</td></tr>
+<tr class="memdesc:af6bf09a0b3c09245257af113e70269d2 inherit pub_methods_classsigc_1_1slot7"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot7.html#af6bf09a0b3c09245257af113e70269d2">More...</a><br /></td></tr>
+<tr class="separator:af6bf09a0b3c09245257af113e70269d2 inherit pub_methods_classsigc_1_1slot7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a82b499c48909c51c4dad097885804638 inherit pub_methods_classsigc_1_1slot7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot7.html">slot7</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#a82b499c48909c51c4dad097885804638">operator=</a> (<a class="el" href="classsigc_1_1slot7.html">slot7</a> && src)</td></tr>
+<tr class="memdesc:a82b499c48909c51c4dad097885804638 inherit pub_methods_classsigc_1_1slot7"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot7.html#a82b499c48909c51c4dad097885804638">More...</a><br /></td></tr>
+<tr class="separator:a82b499c48909c51c4dad097885804638 inherit pub_methods_classsigc_1_1slot7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a> () noexcept</td></tr>
+<tr class="memdesc:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an empty slot. <a href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">More...</a><br /></td></tr>
+<tr class="separator:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">More...</a><br /></td></tr>
+<tr class="separator:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a> (rep_type * rep) noexcept</td></tr>
+<tr class="memdesc:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an existing slot_rep object. <a href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">More...</a><br /></td></tr>
+<tr class="separator:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">More...</a><br /></td></tr>
+<tr class="separator:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a> ()</td></tr>
+<tr class="separator:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the slot is detroyed. <a href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">More...</a><br /></td></tr>
+<tr class="separator:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state. <a href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">More...</a><br /></td></tr>
+<tr class="separator:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">More...</a><br /></td></tr>
+<tr class="separator:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a> ()</td></tr>
+<tr class="memdesc:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Disconnects the slot. <a href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">More...</a><br /></td></tr>
+<tr class="separator:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is invalid. <a href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">More...</a><br /></td></tr>
+<tr class="separator:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a> () const noexcept</td></tr>
+<tr class="memdesc:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Tests whether a slot is null, because the default constructor was used. <a href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">More...</a><br /></td></tr>
+<tr class="separator:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">operator=</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">More...</a><br /></td></tr>
+<tr class="separator:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">operator=</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">More...</a><br /></td></tr>
+<tr class="separator:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694" title="Add a callback that is executed (notified) when the slot is detroyed.">add_destroy_notify_callback()</a>. <a href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">More...</a><br /></td></tr>
+<tr class="separator:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a> (void * parent, void *(* cleanup)(void *)) const noexcept</td></tr>
+<tr class="memdesc:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the parent of this slot. <a href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">More...</a><br /></td></tr>
+<tr class="separator:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state. <a href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">More...</a><br /></td></tr>
+<tr class="separator:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_attribs_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td></tr>
+<tr class="memdesc:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Indicates whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">More...</a><br /></td></tr>
+<tr class="separator:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">rep_type * </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td></tr>
+<tr class="memdesc:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Typed slot_rep object that contains a functor. <a href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">More...</a><br /></td></tr>
+<tr class="separator:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1 = nil, class T_arg2 = nil, class T_arg3 = nil, class T_arg4 = nil, class T_arg5 = nil, class T_arg6 = nil, class T_arg7 = nil><br />
+class sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a># templates. </p>
+<p>Slots convert arbitrary functors to unified types which are opaque. <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> itself is a functor or to be more precise a closure. It contains a single, arbitrary functor (or closure) that is executed in <a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>.</p>
+<p>The template arguments determine the function signature of <a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>:</p><ul>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>.</li>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg6</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg7</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+</ul>
+<p>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. <a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9" title="Sets the blocking state.">block()</a> and <a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d" title="Unsets the blocking state.">unblock()</a> can be used to temporarily block the functor's invocation from <a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>.</p>
+<dl class="section user"><dt>Example:</dt><dd><div class="fragment"><div class="line"><span class="keywordtype">void</span> foo(<span class="keywordtype">int</span>) {}</div>
+<div class="line"><a class="code" href="classsigc_1_1slot.html">sigc::slot<void, int></a> s = <a class="code" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863">sigc::ptr_fun</a>(&foo);</div>
+<div class="line">s(19);</div>
+<div class="ttc" id="aclasssigc_1_1slot_html"><div class="ttname"><a href="classsigc_1_1slot.html">sigc::slot</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::slot# templates.</div><div class="ttdef"><b>Definition:</b> slot.h:1645</div></div>
+<div class="ttc" id="agroup__ptr__fun_html_ga9c80de72f656fb05e81fda622dddc863"><div class="ttname"><a href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863">sigc::ptr_fun</a></div><div class="ttdeci">pointer_functor0< T_return > ptr_fun(T_return(*_A_func)())</div><div class="ttdoc">Creates a functor of type sigc::pointer_functor0 which wraps an existing non-member function.</div><div class="ttdef"><b>Definition:</b> ptr_fun.h:460</div></div>
+</div><!-- fragment --></dd></dl>
+<p>sigc::slot<> is similar to std::function<>. If you're going to assign the resulting functor to a <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> or connect it to a <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a>, it's better not to use std::function. It would become an unnecessary extra wrapper.</p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000194">Deprecated:</a></b></dt><dd>Please use the syntax similar to that used by std::function<>: </dd></dl>
+<div class="fragment"><div class="line"><a class="code" href="classsigc_1_1slot.html">sigc::slot</a><void(<span class="keywordtype">bool</span>, <span class="keywordtype">int</span>)> some_slot;</div>
+</div><!-- fragment --> </div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a1966941e9654adfb3af4b994fd18a7f3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1966941e9654adfb3af4b994fd18a7f3">◆ </a></span>parent_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 = nil, class T_arg2 = nil, class T_arg3 = nil, class T_arg4 = nil, class T_arg5 = nil, class T_arg6 = nil, class T_arg7 = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="classsigc_1_1slot7.html">slot7</a><T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> <a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1slot.html#a1966941e9654adfb3af4b994fd18a7f3">parent_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="af643a8ef3eafd24f738224bbd6056fa3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af643a8ef3eafd24f738224bbd6056fa3">◆ </a></span>slot() <span class="overload">[1/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 = nil, class T_arg2 = nil, class T_arg3 = nil, class T_arg4 = nil, class T_arg5 = nil, class T_arg6 = nil, class T_arg7 = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ad790b9eb2c959f0f266dc94c0e84dd35"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad790b9eb2c959f0f266dc94c0e84dd35">◆ </a></span>slot() <span class="overload">[2/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 = nil, class T_arg2 = nil, class T_arg3 = nil, class T_arg4 = nil, class T_arg5 = nil, class T_arg6 = nil, class T_arg7 = nil> </div>
+<div class="memtemplate">
+template <class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot from an arbitrary functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>The desired functor the new slot should be assigned to. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="ac53122c7f0f1f4dd9493e9ac88837ae2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac53122c7f0f1f4dd9493e9ac88837ae2">◆ </a></span>slot() <span class="overload">[3/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 = nil, class T_arg2 = nil, class T_arg3 = nil, class T_arg4 = nil, class T_arg5 = nil, class T_arg6 = nil, class T_arg7 = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, copying an existing one. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a445f8243e1eac20f8f925824c4acf4cf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a445f8243e1eac20f8f925824c4acf4cf">◆ </a></span>slot() <span class="overload">[4/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 = nil, class T_arg2 = nil, class T_arg3 = nil, class T_arg4 = nil, class T_arg5 = nil, class T_arg6 = nil, class T_arg7 = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, moving an existing one. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="ac7beb1ab973b6cd124d2cdea3f0c1e0c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac7beb1ab973b6cd124d2cdea3f0c1e0c">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 = nil, class T_arg2 = nil, class T_arg3 = nil, class T_arg4 = nil, class T_arg5 = nil, class T_arg6 = nil, class T_arg7 = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">slot</a>& <a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a copy from another slot. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to make a copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+<a id="a0f4ef3f59a7f7228b8b4fddabdbd6924"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0f4ef3f59a7f7228b8b4fddabdbd6924">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 = nil, class T_arg2 = nil, class T_arg3 = nil, class T_arg4 = nil, class T_arg5 = nil, class T_arg6 = nil, class T_arg7 = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">slot</a>& <a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a move from another slot. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot0.html">slot0</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::slot0< T_return > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1slot0.html">sigc::slot0< T_return ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot0.html#afa926436a4b0734f0adc2a485ccfe36a">operator()</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1slot0.html">sigc::slot0< T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot0.html#a49bba0540dcc76fb19e49d19a1acd563">operator=</a>(const slot0 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot0.html">sigc::slot0< T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot0.html#a95205051379e5d5657bac78c9b3b8d49">operator=</a>(slot0 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot0.html">sigc::slot0< T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">sigc::slot_base::operator=</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">sigc::slot_base::operator=</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot0.html#aca0c967b605e09d5a87015d95e93d4f7">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot0.html">sigc::slot0< T_return ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a>(void * parent, void *(* cleanup)(void *)) const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot0.html#a8681082ecd439d5b294922e4d27a3f49">slot0</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot0.html">sigc::slot0< T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot0.html#a83a247c06b93ef644bdfe0bf119929c0">slot0</a>(const T_functor & _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1slot0.html">sigc::slot0< T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot0.html#acce9a5d9a4f939e405383092ba717f72">slot0</a>(const slot0 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot0.html">sigc::slot0< T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot0.html#ac93b53e3d90df14b2b003ad0c685b160">slot0</a>(slot0 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot0.html">sigc::slot0< T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a>(rep_type * rep) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::slot0< T_return > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot0.html">slot0</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1slot0-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::slot0< T_return > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__slot.html">Slots</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Converts an arbitrary functor to a unified type which is opaque.
+ <a href="classsigc_1_1slot0.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/slot.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::slot0< T_return >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1slot0__inherit__graph.png" border="0" usemap="#asigc_1_1slot0_3_01T__return_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1slot0_3_01T__return_01_4_inherit__map" id="asigc_1_1slot0_3_01T__return_01_4_inherit__map">
+<area shape="rect" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="5,155,177,181"/>
+<area shape="rect" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot0 template." alt="" coords="15,229,168,285"/>
+<area shape="rect" href="classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="32,80,151,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="21,5,161,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:aca0c967b605e09d5a87015d95e93d4f7"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot0.html#aca0c967b605e09d5a87015d95e93d4f7">result_type</a></td></tr>
+<tr class="separator:aca0c967b605e09d5a87015d95e93d4f7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">trackable::func_destroy_notify</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a></td></tr>
+<tr class="separator:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a8681082ecd439d5b294922e4d27a3f49"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot0.html#a8681082ecd439d5b294922e4d27a3f49">slot0</a> ()</td></tr>
+<tr class="separator:a8681082ecd439d5b294922e4d27a3f49"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acce9a5d9a4f939e405383092ba717f72"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot0.html#acce9a5d9a4f939e405383092ba717f72">slot0</a> (const <a class="el" href="classsigc_1_1slot0.html">slot0</a> & src)</td></tr>
+<tr class="memdesc:acce9a5d9a4f939e405383092ba717f72"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot0.html#acce9a5d9a4f939e405383092ba717f72">More...</a><br /></td></tr>
+<tr class="separator:acce9a5d9a4f939e405383092ba717f72"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a83a247c06b93ef644bdfe0bf119929c0"><td class="memTemplParams" colspan="2">template<class T_functor > </td></tr>
+<tr class="memitem:a83a247c06b93ef644bdfe0bf119929c0"><td class="memTemplItemLeft" align="right" valign="top"> </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot0.html#a83a247c06b93ef644bdfe0bf119929c0">slot0</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:a83a247c06b93ef644bdfe0bf119929c0"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an arbitrary functor. <a href="classsigc_1_1slot0.html#a83a247c06b93ef644bdfe0bf119929c0">More...</a><br /></td></tr>
+<tr class="separator:a83a247c06b93ef644bdfe0bf119929c0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac93b53e3d90df14b2b003ad0c685b160"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot0.html#ac93b53e3d90df14b2b003ad0c685b160">slot0</a> (<a class="el" href="classsigc_1_1slot0.html">slot0</a> && src)</td></tr>
+<tr class="memdesc:ac93b53e3d90df14b2b003ad0c685b160"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot0.html#ac93b53e3d90df14b2b003ad0c685b160">More...</a><br /></td></tr>
+<tr class="separator:ac93b53e3d90df14b2b003ad0c685b160"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa926436a4b0734f0adc2a485ccfe36a"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot0.html#afa926436a4b0734f0adc2a485ccfe36a">operator()</a> () const</td></tr>
+<tr class="memdesc:afa926436a4b0734f0adc2a485ccfe36a"><td class="mdescLeft"> </td><td class="mdescRight">Invoke the contained functor unless slot is in blocking state. <a href="classsigc_1_1slot0.html#afa926436a4b0734f0adc2a485ccfe36a">More...</a><br /></td></tr>
+<tr class="separator:afa926436a4b0734f0adc2a485ccfe36a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a49bba0540dcc76fb19e49d19a1acd563"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot0.html">slot0</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot0.html#a49bba0540dcc76fb19e49d19a1acd563">operator=</a> (const <a class="el" href="classsigc_1_1slot0.html">slot0</a> & src)</td></tr>
+<tr class="memdesc:a49bba0540dcc76fb19e49d19a1acd563"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot0.html#a49bba0540dcc76fb19e49d19a1acd563">More...</a><br /></td></tr>
+<tr class="separator:a49bba0540dcc76fb19e49d19a1acd563"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a95205051379e5d5657bac78c9b3b8d49"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot0.html">slot0</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot0.html#a95205051379e5d5657bac78c9b3b8d49">operator=</a> (<a class="el" href="classsigc_1_1slot0.html">slot0</a> && src)</td></tr>
+<tr class="memdesc:a95205051379e5d5657bac78c9b3b8d49"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot0.html#a95205051379e5d5657bac78c9b3b8d49">More...</a><br /></td></tr>
+<tr class="separator:a95205051379e5d5657bac78c9b3b8d49"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a> () noexcept</td></tr>
+<tr class="memdesc:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an empty slot. <a href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">More...</a><br /></td></tr>
+<tr class="separator:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">More...</a><br /></td></tr>
+<tr class="separator:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a> (rep_type * rep) noexcept</td></tr>
+<tr class="memdesc:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an existing slot_rep object. <a href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">More...</a><br /></td></tr>
+<tr class="separator:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">More...</a><br /></td></tr>
+<tr class="separator:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a> ()</td></tr>
+<tr class="separator:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the slot is detroyed. <a href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">More...</a><br /></td></tr>
+<tr class="separator:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state. <a href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">More...</a><br /></td></tr>
+<tr class="separator:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">More...</a><br /></td></tr>
+<tr class="separator:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a> ()</td></tr>
+<tr class="memdesc:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Disconnects the slot. <a href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">More...</a><br /></td></tr>
+<tr class="separator:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is invalid. <a href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">More...</a><br /></td></tr>
+<tr class="separator:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a> () const noexcept</td></tr>
+<tr class="memdesc:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Tests whether a slot is null, because the default constructor was used. <a href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">More...</a><br /></td></tr>
+<tr class="separator:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">operator=</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">More...</a><br /></td></tr>
+<tr class="separator:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">operator=</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">More...</a><br /></td></tr>
+<tr class="separator:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694" title="Add a callback that is executed (notified) when the slot is detroyed.">add_destroy_notify_callback()</a>. <a href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">More...</a><br /></td></tr>
+<tr class="separator:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a> (void * parent, void *(* cleanup)(void *)) const noexcept</td></tr>
+<tr class="memdesc:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the parent of this slot. <a href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">More...</a><br /></td></tr>
+<tr class="separator:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state. <a href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">More...</a><br /></td></tr>
+<tr class="separator:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_attribs_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td></tr>
+<tr class="memdesc:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Indicates whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">More...</a><br /></td></tr>
+<tr class="separator:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">rep_type * </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td></tr>
+<tr class="memdesc:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Typed slot_rep object that contains a functor. <a href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">More...</a><br /></td></tr>
+<tr class="separator:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return><br />
+class sigc::slot0< T_return ></h3>
+
+<p>Converts an arbitrary functor to a unified type which is opaque. </p>
+<p><a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> itself is a functor or to be more precise a closure. It contains a single, arbitrary functor (or closure) that is executed in <a class="el" href="classsigc_1_1slot0.html#afa926436a4b0734f0adc2a485ccfe36a" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>.</p>
+<p>The template arguments determine the function signature of <a class="el" href="classsigc_1_1slot0.html#afa926436a4b0734f0adc2a485ccfe36a" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>:</p><ul>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1slot0.html#afa926436a4b0734f0adc2a485ccfe36a" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>.</li>
+</ul>
+<p>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. <a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9" title="Sets the blocking state.">block()</a> and <a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d" title="Unsets the blocking state.">unblock()</a> can be used to block the functor's invocation from <a class="el" href="classsigc_1_1slot0.html#afa926436a4b0734f0adc2a485ccfe36a" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a> temporarily.</p>
+<p>You should use the more convenient unnumbered <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> template. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="aca0c967b605e09d5a87015d95e93d4f7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aca0c967b605e09d5a87015d95e93d4f7">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1slot0.html">sigc::slot0</a>< T_return >::<a class="el" href="classsigc_1_1slot0.html#aca0c967b605e09d5a87015d95e93d4f7">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a8681082ecd439d5b294922e4d27a3f49"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8681082ecd439d5b294922e4d27a3f49">◆ </a></span>slot0() <span class="overload">[1/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot0.html">sigc::slot0</a>< T_return >::<a class="el" href="classsigc_1_1slot0.html">slot0</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a83a247c06b93ef644bdfe0bf119929c0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a83a247c06b93ef644bdfe0bf119929c0">◆ </a></span>slot0() <span class="overload">[2/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<div class="memtemplate">
+template <class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot0.html">sigc::slot0</a>< T_return >::<a class="el" href="classsigc_1_1slot0.html">slot0</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot from an arbitrary functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>The desired functor the new slot should be assigned to. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="acce9a5d9a4f939e405383092ba717f72"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#acce9a5d9a4f939e405383092ba717f72">◆ </a></span>slot0() <span class="overload">[3/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot0.html">sigc::slot0</a>< T_return >::<a class="el" href="classsigc_1_1slot0.html">slot0</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot0.html">slot0</a>< T_return > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, copying an existing one. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="ac93b53e3d90df14b2b003ad0c685b160"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac93b53e3d90df14b2b003ad0c685b160">◆ </a></span>slot0() <span class="overload">[4/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot0.html">sigc::slot0</a>< T_return >::<a class="el" href="classsigc_1_1slot0.html">slot0</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot0.html">slot0</a>< T_return > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, moving an existing one. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="afa926436a4b0734f0adc2a485ccfe36a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#afa926436a4b0734f0adc2a485ccfe36a">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1slot0.html">sigc::slot0</a>< T_return >::operator() </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invoke the contained functor unless slot is in blocking state. </p>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a49bba0540dcc76fb19e49d19a1acd563"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a49bba0540dcc76fb19e49d19a1acd563">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot0.html">slot0</a>& <a class="el" href="classsigc_1_1slot0.html">sigc::slot0</a>< T_return >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot0.html">slot0</a>< T_return > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a copy from another slot. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to make a copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+<a id="a95205051379e5d5657bac78c9b3b8d49"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a95205051379e5d5657bac78c9b3b8d49">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot0.html">slot0</a>& <a class="el" href="classsigc_1_1slot0.html">sigc::slot0</a>< T_return >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot0.html">slot0</a>< T_return > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a move from another slot. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::slot0< T_return >" name="sigc::slot0< T_return >">
+<area shape="rect" id="node1" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="5,155,177,181"/>
+<area shape="rect" id="node4" href="$classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot0 template." alt="" coords="15,229,168,285"/>
+<area shape="rect" id="node2" href="$classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="32,80,151,107"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="21,5,161,32"/>
+</map>
--- /dev/null
+d59c3801d163d72dda5ca9ff92712854
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot1.html">slot1</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::slot1< T_return, T_arg1 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1slot1.html">sigc::slot1< T_return, T_arg1 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot1.html#a4d81838957a9ccc6cb4c104706a37a89">arg1_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot1.html">sigc::slot1< T_return, T_arg1 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot1.html#ae9082daf31fdbb57da71e8c38a9ae1ab">operator()</a>(arg1_type_ _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1slot1.html">sigc::slot1< T_return, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot1.html#a2e0d65cfc434718b6c5f7d7135ac384e">operator=</a>(const slot1 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot1.html">sigc::slot1< T_return, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot1.html#a195acd57b42149a2faaeec4c6725825a">operator=</a>(slot1 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot1.html">sigc::slot1< T_return, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">sigc::slot_base::operator=</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">sigc::slot_base::operator=</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot1.html#ab4991fe5d80761ddab482fda9ebe6d17">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot1.html">sigc::slot1< T_return, T_arg1 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a>(void * parent, void *(* cleanup)(void *)) const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot1.html#aa8ac5eadba778c11a424e255889e67f6">slot1</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot1.html">sigc::slot1< T_return, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot1.html#a20999708c6db16a3015beca7d4ad866e">slot1</a>(const T_functor & _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1slot1.html">sigc::slot1< T_return, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot1.html#ac6ecaff0a20a57d2168ea126e565e36a">slot1</a>(const slot1 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot1.html">sigc::slot1< T_return, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot1.html#a4ab8f18f97f843558f11adb9d1e8e478">slot1</a>(slot1 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot1.html">sigc::slot1< T_return, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a>(rep_type * rep) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::slot1< T_return, T_arg1 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot1.html">slot1</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1slot1-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::slot1< T_return, T_arg1 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__slot.html">Slots</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Converts an arbitrary functor to a unified type which is opaque.
+ <a href="classsigc_1_1slot1.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/slot.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::slot1< T_return, T_arg1 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1slot1__inherit__graph.png" border="0" usemap="#asigc_1_1slot1_3_01T__return_00_01T__arg1_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1slot1_3_01T__return_00_01T__arg1_01_4_inherit__map" id="asigc_1_1slot1_3_01T__return_00_01T__arg1_01_4_inherit__map">
+<area shape="rect" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="5,155,167,196"/>
+<area shape="rect" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot1 template." alt="" coords="9,244,163,300"/>
+<area shape="rect" href="classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="27,80,145,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="16,5,156,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a4d81838957a9ccc6cb4c104706a37a89"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot1.html#a4d81838957a9ccc6cb4c104706a37a89">arg1_type_</a></td></tr>
+<tr class="separator:a4d81838957a9ccc6cb4c104706a37a89"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab4991fe5d80761ddab482fda9ebe6d17"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot1.html#ab4991fe5d80761ddab482fda9ebe6d17">result_type</a></td></tr>
+<tr class="separator:ab4991fe5d80761ddab482fda9ebe6d17"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">trackable::func_destroy_notify</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a></td></tr>
+<tr class="separator:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:aa8ac5eadba778c11a424e255889e67f6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot1.html#aa8ac5eadba778c11a424e255889e67f6">slot1</a> ()</td></tr>
+<tr class="separator:aa8ac5eadba778c11a424e255889e67f6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac6ecaff0a20a57d2168ea126e565e36a"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot1.html#ac6ecaff0a20a57d2168ea126e565e36a">slot1</a> (const <a class="el" href="classsigc_1_1slot1.html">slot1</a> & src)</td></tr>
+<tr class="memdesc:ac6ecaff0a20a57d2168ea126e565e36a"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot1.html#ac6ecaff0a20a57d2168ea126e565e36a">More...</a><br /></td></tr>
+<tr class="separator:ac6ecaff0a20a57d2168ea126e565e36a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a20999708c6db16a3015beca7d4ad866e"><td class="memTemplParams" colspan="2">template<class T_functor > </td></tr>
+<tr class="memitem:a20999708c6db16a3015beca7d4ad866e"><td class="memTemplItemLeft" align="right" valign="top"> </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot1.html#a20999708c6db16a3015beca7d4ad866e">slot1</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:a20999708c6db16a3015beca7d4ad866e"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an arbitrary functor. <a href="classsigc_1_1slot1.html#a20999708c6db16a3015beca7d4ad866e">More...</a><br /></td></tr>
+<tr class="separator:a20999708c6db16a3015beca7d4ad866e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4ab8f18f97f843558f11adb9d1e8e478"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot1.html#a4ab8f18f97f843558f11adb9d1e8e478">slot1</a> (<a class="el" href="classsigc_1_1slot1.html">slot1</a> && src)</td></tr>
+<tr class="memdesc:a4ab8f18f97f843558f11adb9d1e8e478"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot1.html#a4ab8f18f97f843558f11adb9d1e8e478">More...</a><br /></td></tr>
+<tr class="separator:a4ab8f18f97f843558f11adb9d1e8e478"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae9082daf31fdbb57da71e8c38a9ae1ab"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot1.html#ae9082daf31fdbb57da71e8c38a9ae1ab">operator()</a> (<a class="el" href="classsigc_1_1slot1.html#a4d81838957a9ccc6cb4c104706a37a89">arg1_type_</a> _A_a1) const</td></tr>
+<tr class="memdesc:ae9082daf31fdbb57da71e8c38a9ae1ab"><td class="mdescLeft"> </td><td class="mdescRight">Invoke the contained functor unless slot is in blocking state. <a href="classsigc_1_1slot1.html#ae9082daf31fdbb57da71e8c38a9ae1ab">More...</a><br /></td></tr>
+<tr class="separator:ae9082daf31fdbb57da71e8c38a9ae1ab"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2e0d65cfc434718b6c5f7d7135ac384e"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot1.html">slot1</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot1.html#a2e0d65cfc434718b6c5f7d7135ac384e">operator=</a> (const <a class="el" href="classsigc_1_1slot1.html">slot1</a> & src)</td></tr>
+<tr class="memdesc:a2e0d65cfc434718b6c5f7d7135ac384e"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot1.html#a2e0d65cfc434718b6c5f7d7135ac384e">More...</a><br /></td></tr>
+<tr class="separator:a2e0d65cfc434718b6c5f7d7135ac384e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a195acd57b42149a2faaeec4c6725825a"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot1.html">slot1</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot1.html#a195acd57b42149a2faaeec4c6725825a">operator=</a> (<a class="el" href="classsigc_1_1slot1.html">slot1</a> && src)</td></tr>
+<tr class="memdesc:a195acd57b42149a2faaeec4c6725825a"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot1.html#a195acd57b42149a2faaeec4c6725825a">More...</a><br /></td></tr>
+<tr class="separator:a195acd57b42149a2faaeec4c6725825a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a> () noexcept</td></tr>
+<tr class="memdesc:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an empty slot. <a href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">More...</a><br /></td></tr>
+<tr class="separator:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">More...</a><br /></td></tr>
+<tr class="separator:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a> (rep_type * rep) noexcept</td></tr>
+<tr class="memdesc:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an existing slot_rep object. <a href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">More...</a><br /></td></tr>
+<tr class="separator:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">More...</a><br /></td></tr>
+<tr class="separator:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a> ()</td></tr>
+<tr class="separator:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the slot is detroyed. <a href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">More...</a><br /></td></tr>
+<tr class="separator:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state. <a href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">More...</a><br /></td></tr>
+<tr class="separator:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">More...</a><br /></td></tr>
+<tr class="separator:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a> ()</td></tr>
+<tr class="memdesc:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Disconnects the slot. <a href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">More...</a><br /></td></tr>
+<tr class="separator:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is invalid. <a href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">More...</a><br /></td></tr>
+<tr class="separator:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a> () const noexcept</td></tr>
+<tr class="memdesc:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Tests whether a slot is null, because the default constructor was used. <a href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">More...</a><br /></td></tr>
+<tr class="separator:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">operator=</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">More...</a><br /></td></tr>
+<tr class="separator:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">operator=</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">More...</a><br /></td></tr>
+<tr class="separator:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694" title="Add a callback that is executed (notified) when the slot is detroyed.">add_destroy_notify_callback()</a>. <a href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">More...</a><br /></td></tr>
+<tr class="separator:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a> (void * parent, void *(* cleanup)(void *)) const noexcept</td></tr>
+<tr class="memdesc:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the parent of this slot. <a href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">More...</a><br /></td></tr>
+<tr class="separator:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state. <a href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">More...</a><br /></td></tr>
+<tr class="separator:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_attribs_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td></tr>
+<tr class="memdesc:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Indicates whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">More...</a><br /></td></tr>
+<tr class="separator:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">rep_type * </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td></tr>
+<tr class="memdesc:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Typed slot_rep object that contains a functor. <a href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">More...</a><br /></td></tr>
+<tr class="separator:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1><br />
+class sigc::slot1< T_return, T_arg1 ></h3>
+
+<p>Converts an arbitrary functor to a unified type which is opaque. </p>
+<p><a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> itself is a functor or to be more precise a closure. It contains a single, arbitrary functor (or closure) that is executed in <a class="el" href="classsigc_1_1slot1.html#ae9082daf31fdbb57da71e8c38a9ae1ab" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>.</p>
+<p>The template arguments determine the function signature of <a class="el" href="classsigc_1_1slot1.html#ae9082daf31fdbb57da71e8c38a9ae1ab" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>:</p><ul>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1slot1.html#ae9082daf31fdbb57da71e8c38a9ae1ab" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>.</li>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot1.html#ae9082daf31fdbb57da71e8c38a9ae1ab" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+</ul>
+<p>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. <a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9" title="Sets the blocking state.">block()</a> and <a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d" title="Unsets the blocking state.">unblock()</a> can be used to block the functor's invocation from <a class="el" href="classsigc_1_1slot1.html#ae9082daf31fdbb57da71e8c38a9ae1ab" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a> temporarily.</p>
+<p>You should use the more convenient unnumbered <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> template. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a4d81838957a9ccc6cb4c104706a37a89"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4d81838957a9ccc6cb4c104706a37a89">◆ </a></span>arg1_type_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg1> <a class="el" href="classsigc_1_1slot1.html">sigc::slot1</a>< T_return, T_arg1 >::<a class="el" href="classsigc_1_1slot1.html#a4d81838957a9ccc6cb4c104706a37a89">arg1_type_</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ab4991fe5d80761ddab482fda9ebe6d17"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab4991fe5d80761ddab482fda9ebe6d17">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1slot1.html">sigc::slot1</a>< T_return, T_arg1 >::<a class="el" href="classsigc_1_1slot1.html#ab4991fe5d80761ddab482fda9ebe6d17">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="aa8ac5eadba778c11a424e255889e67f6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa8ac5eadba778c11a424e255889e67f6">◆ </a></span>slot1() <span class="overload">[1/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot1.html">sigc::slot1</a>< T_return, T_arg1 >::<a class="el" href="classsigc_1_1slot1.html">slot1</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a20999708c6db16a3015beca7d4ad866e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a20999708c6db16a3015beca7d4ad866e">◆ </a></span>slot1() <span class="overload">[2/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+<div class="memtemplate">
+template <class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot1.html">sigc::slot1</a>< T_return, T_arg1 >::<a class="el" href="classsigc_1_1slot1.html">slot1</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot from an arbitrary functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>The desired functor the new slot should be assigned to. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="ac6ecaff0a20a57d2168ea126e565e36a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac6ecaff0a20a57d2168ea126e565e36a">◆ </a></span>slot1() <span class="overload">[3/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot1.html">sigc::slot1</a>< T_return, T_arg1 >::<a class="el" href="classsigc_1_1slot1.html">slot1</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot1.html">slot1</a>< T_return, T_arg1 > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, copying an existing one. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a4ab8f18f97f843558f11adb9d1e8e478"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4ab8f18f97f843558f11adb9d1e8e478">◆ </a></span>slot1() <span class="overload">[4/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot1.html">sigc::slot1</a>< T_return, T_arg1 >::<a class="el" href="classsigc_1_1slot1.html">slot1</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot1.html">slot1</a>< T_return, T_arg1 > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, moving an existing one. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="ae9082daf31fdbb57da71e8c38a9ae1ab"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae9082daf31fdbb57da71e8c38a9ae1ab">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1slot1.html">sigc::slot1</a>< T_return, T_arg1 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot1.html#a4d81838957a9ccc6cb4c104706a37a89">arg1_type_</a> </td>
+ <td class="paramname"><em>_A_a1</em></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invoke the contained functor unless slot is in blocking state. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a2e0d65cfc434718b6c5f7d7135ac384e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2e0d65cfc434718b6c5f7d7135ac384e">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot1.html">slot1</a>& <a class="el" href="classsigc_1_1slot1.html">sigc::slot1</a>< T_return, T_arg1 >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot1.html">slot1</a>< T_return, T_arg1 > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a copy from another slot. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to make a copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+<a id="a195acd57b42149a2faaeec4c6725825a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a195acd57b42149a2faaeec4c6725825a">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot1.html">slot1</a>& <a class="el" href="classsigc_1_1slot1.html">sigc::slot1</a>< T_return, T_arg1 >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot1.html">slot1</a>< T_return, T_arg1 > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a move from another slot. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::slot1< T_return, T_arg1 >" name="sigc::slot1< T_return, T_arg1 >">
+<area shape="rect" id="node1" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="5,155,167,196"/>
+<area shape="rect" id="node4" href="$classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot1 template." alt="" coords="9,244,163,300"/>
+<area shape="rect" id="node2" href="$classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="27,80,145,107"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="16,5,156,32"/>
+</map>
--- /dev/null
+e5a39f474a0e218e6ea140dc3cec578c
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot2.html">slot2</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::slot2< T_return, T_arg1, T_arg2 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1slot2.html">sigc::slot2< T_return, T_arg1, T_arg2 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot2.html#ae69b03a4119d61a0a521b0ad5ddaae46">arg1_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot2.html">sigc::slot2< T_return, T_arg1, T_arg2 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot2.html#af03b1377bbfcdc742a7c00f4c2c419f7">arg2_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot2.html">sigc::slot2< T_return, T_arg1, T_arg2 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot2.html#aa2abda2a910db19bbb7a2a08d867e358">operator()</a>(arg1_type_ _A_a1, arg2_type_ _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1slot2.html">sigc::slot2< T_return, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot2.html#a6b3d5de4d2e7a6134cc883b98380caa7">operator=</a>(const slot2 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot2.html">sigc::slot2< T_return, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot2.html#aeda5a84c674376aa0800a0bf876bb5fa">operator=</a>(slot2 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot2.html">sigc::slot2< T_return, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">sigc::slot_base::operator=</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">sigc::slot_base::operator=</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot2.html#a0bb920e3d5628c3d01a4337a2a8a97fc">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot2.html">sigc::slot2< T_return, T_arg1, T_arg2 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a>(void * parent, void *(* cleanup)(void *)) const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot2.html#a3f9f6cf199bbb40011eca25eb9da67c2">slot2</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot2.html">sigc::slot2< T_return, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot2.html#a14641110a8fdbb060a58c037b9000730">slot2</a>(const T_functor & _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1slot2.html">sigc::slot2< T_return, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot2.html#a868deef9d947dfa4fcbb0cfe64cbd42e">slot2</a>(const slot2 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot2.html">sigc::slot2< T_return, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot2.html#a4719ba9494f87e682b6a6d04b02413e7">slot2</a>(slot2 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot2.html">sigc::slot2< T_return, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a>(rep_type * rep) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::slot2< T_return, T_arg1, T_arg2 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot2.html">slot2</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1slot2-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::slot2< T_return, T_arg1, T_arg2 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__slot.html">Slots</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Converts an arbitrary functor to a unified type which is opaque.
+ <a href="classsigc_1_1slot2.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/slot.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::slot2< T_return, T_arg1, T_arg2 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1slot2__inherit__graph.png" border="0" usemap="#asigc_1_1slot2_3_01T__return_00_01T__arg1_00_01T__arg2_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1slot2_3_01T__return_00_01T__arg1_00_01T__arg2_01_4_inherit__map" id="asigc_1_1slot2_3_01T__return_00_01T__arg1_00_01T__arg2_01_4_inherit__map">
+<area shape="rect" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="5,155,167,196"/>
+<area shape="rect" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot2 template." alt="" coords="9,244,163,300"/>
+<area shape="rect" href="classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="27,80,145,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="16,5,156,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:ae69b03a4119d61a0a521b0ad5ddaae46"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot2.html#ae69b03a4119d61a0a521b0ad5ddaae46">arg1_type_</a></td></tr>
+<tr class="separator:ae69b03a4119d61a0a521b0ad5ddaae46"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af03b1377bbfcdc742a7c00f4c2c419f7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot2.html#af03b1377bbfcdc742a7c00f4c2c419f7">arg2_type_</a></td></tr>
+<tr class="separator:af03b1377bbfcdc742a7c00f4c2c419f7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0bb920e3d5628c3d01a4337a2a8a97fc"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot2.html#a0bb920e3d5628c3d01a4337a2a8a97fc">result_type</a></td></tr>
+<tr class="separator:a0bb920e3d5628c3d01a4337a2a8a97fc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">trackable::func_destroy_notify</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a></td></tr>
+<tr class="separator:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a3f9f6cf199bbb40011eca25eb9da67c2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot2.html#a3f9f6cf199bbb40011eca25eb9da67c2">slot2</a> ()</td></tr>
+<tr class="separator:a3f9f6cf199bbb40011eca25eb9da67c2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a868deef9d947dfa4fcbb0cfe64cbd42e"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot2.html#a868deef9d947dfa4fcbb0cfe64cbd42e">slot2</a> (const <a class="el" href="classsigc_1_1slot2.html">slot2</a> & src)</td></tr>
+<tr class="memdesc:a868deef9d947dfa4fcbb0cfe64cbd42e"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot2.html#a868deef9d947dfa4fcbb0cfe64cbd42e">More...</a><br /></td></tr>
+<tr class="separator:a868deef9d947dfa4fcbb0cfe64cbd42e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a14641110a8fdbb060a58c037b9000730"><td class="memTemplParams" colspan="2">template<class T_functor > </td></tr>
+<tr class="memitem:a14641110a8fdbb060a58c037b9000730"><td class="memTemplItemLeft" align="right" valign="top"> </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot2.html#a14641110a8fdbb060a58c037b9000730">slot2</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:a14641110a8fdbb060a58c037b9000730"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an arbitrary functor. <a href="classsigc_1_1slot2.html#a14641110a8fdbb060a58c037b9000730">More...</a><br /></td></tr>
+<tr class="separator:a14641110a8fdbb060a58c037b9000730"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4719ba9494f87e682b6a6d04b02413e7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot2.html#a4719ba9494f87e682b6a6d04b02413e7">slot2</a> (<a class="el" href="classsigc_1_1slot2.html">slot2</a> && src)</td></tr>
+<tr class="memdesc:a4719ba9494f87e682b6a6d04b02413e7"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot2.html#a4719ba9494f87e682b6a6d04b02413e7">More...</a><br /></td></tr>
+<tr class="separator:a4719ba9494f87e682b6a6d04b02413e7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa2abda2a910db19bbb7a2a08d867e358"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot2.html#aa2abda2a910db19bbb7a2a08d867e358">operator()</a> (<a class="el" href="classsigc_1_1slot2.html#ae69b03a4119d61a0a521b0ad5ddaae46">arg1_type_</a> _A_a1, <a class="el" href="classsigc_1_1slot2.html#af03b1377bbfcdc742a7c00f4c2c419f7">arg2_type_</a> _A_a2) const</td></tr>
+<tr class="memdesc:aa2abda2a910db19bbb7a2a08d867e358"><td class="mdescLeft"> </td><td class="mdescRight">Invoke the contained functor unless slot is in blocking state. <a href="classsigc_1_1slot2.html#aa2abda2a910db19bbb7a2a08d867e358">More...</a><br /></td></tr>
+<tr class="separator:aa2abda2a910db19bbb7a2a08d867e358"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a6b3d5de4d2e7a6134cc883b98380caa7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot2.html">slot2</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot2.html#a6b3d5de4d2e7a6134cc883b98380caa7">operator=</a> (const <a class="el" href="classsigc_1_1slot2.html">slot2</a> & src)</td></tr>
+<tr class="memdesc:a6b3d5de4d2e7a6134cc883b98380caa7"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot2.html#a6b3d5de4d2e7a6134cc883b98380caa7">More...</a><br /></td></tr>
+<tr class="separator:a6b3d5de4d2e7a6134cc883b98380caa7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aeda5a84c674376aa0800a0bf876bb5fa"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot2.html">slot2</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot2.html#aeda5a84c674376aa0800a0bf876bb5fa">operator=</a> (<a class="el" href="classsigc_1_1slot2.html">slot2</a> && src)</td></tr>
+<tr class="memdesc:aeda5a84c674376aa0800a0bf876bb5fa"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot2.html#aeda5a84c674376aa0800a0bf876bb5fa">More...</a><br /></td></tr>
+<tr class="separator:aeda5a84c674376aa0800a0bf876bb5fa"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a> () noexcept</td></tr>
+<tr class="memdesc:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an empty slot. <a href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">More...</a><br /></td></tr>
+<tr class="separator:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">More...</a><br /></td></tr>
+<tr class="separator:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a> (rep_type * rep) noexcept</td></tr>
+<tr class="memdesc:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an existing slot_rep object. <a href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">More...</a><br /></td></tr>
+<tr class="separator:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">More...</a><br /></td></tr>
+<tr class="separator:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a> ()</td></tr>
+<tr class="separator:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the slot is detroyed. <a href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">More...</a><br /></td></tr>
+<tr class="separator:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state. <a href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">More...</a><br /></td></tr>
+<tr class="separator:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">More...</a><br /></td></tr>
+<tr class="separator:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a> ()</td></tr>
+<tr class="memdesc:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Disconnects the slot. <a href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">More...</a><br /></td></tr>
+<tr class="separator:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is invalid. <a href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">More...</a><br /></td></tr>
+<tr class="separator:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a> () const noexcept</td></tr>
+<tr class="memdesc:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Tests whether a slot is null, because the default constructor was used. <a href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">More...</a><br /></td></tr>
+<tr class="separator:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">operator=</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">More...</a><br /></td></tr>
+<tr class="separator:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">operator=</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">More...</a><br /></td></tr>
+<tr class="separator:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694" title="Add a callback that is executed (notified) when the slot is detroyed.">add_destroy_notify_callback()</a>. <a href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">More...</a><br /></td></tr>
+<tr class="separator:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a> (void * parent, void *(* cleanup)(void *)) const noexcept</td></tr>
+<tr class="memdesc:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the parent of this slot. <a href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">More...</a><br /></td></tr>
+<tr class="separator:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state. <a href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">More...</a><br /></td></tr>
+<tr class="separator:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_attribs_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td></tr>
+<tr class="memdesc:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Indicates whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">More...</a><br /></td></tr>
+<tr class="separator:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">rep_type * </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td></tr>
+<tr class="memdesc:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Typed slot_rep object that contains a functor. <a href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">More...</a><br /></td></tr>
+<tr class="separator:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2><br />
+class sigc::slot2< T_return, T_arg1, T_arg2 ></h3>
+
+<p>Converts an arbitrary functor to a unified type which is opaque. </p>
+<p><a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> itself is a functor or to be more precise a closure. It contains a single, arbitrary functor (or closure) that is executed in <a class="el" href="classsigc_1_1slot2.html#aa2abda2a910db19bbb7a2a08d867e358" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>.</p>
+<p>The template arguments determine the function signature of <a class="el" href="classsigc_1_1slot2.html#aa2abda2a910db19bbb7a2a08d867e358" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>:</p><ul>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1slot2.html#aa2abda2a910db19bbb7a2a08d867e358" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>.</li>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot2.html#aa2abda2a910db19bbb7a2a08d867e358" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot2.html#aa2abda2a910db19bbb7a2a08d867e358" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+</ul>
+<p>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. <a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9" title="Sets the blocking state.">block()</a> and <a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d" title="Unsets the blocking state.">unblock()</a> can be used to block the functor's invocation from <a class="el" href="classsigc_1_1slot2.html#aa2abda2a910db19bbb7a2a08d867e358" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a> temporarily.</p>
+<p>You should use the more convenient unnumbered <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> template. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="ae69b03a4119d61a0a521b0ad5ddaae46"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae69b03a4119d61a0a521b0ad5ddaae46">◆ </a></span>arg1_type_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg1> <a class="el" href="classsigc_1_1slot2.html">sigc::slot2</a>< T_return, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1slot2.html#ae69b03a4119d61a0a521b0ad5ddaae46">arg1_type_</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="af03b1377bbfcdc742a7c00f4c2c419f7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af03b1377bbfcdc742a7c00f4c2c419f7">◆ </a></span>arg2_type_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg2> <a class="el" href="classsigc_1_1slot2.html">sigc::slot2</a>< T_return, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1slot2.html#af03b1377bbfcdc742a7c00f4c2c419f7">arg2_type_</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a0bb920e3d5628c3d01a4337a2a8a97fc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0bb920e3d5628c3d01a4337a2a8a97fc">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1slot2.html">sigc::slot2</a>< T_return, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1slot2.html#a0bb920e3d5628c3d01a4337a2a8a97fc">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a3f9f6cf199bbb40011eca25eb9da67c2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3f9f6cf199bbb40011eca25eb9da67c2">◆ </a></span>slot2() <span class="overload">[1/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot2.html">sigc::slot2</a>< T_return, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1slot2.html">slot2</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a14641110a8fdbb060a58c037b9000730"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a14641110a8fdbb060a58c037b9000730">◆ </a></span>slot2() <span class="overload">[2/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+<div class="memtemplate">
+template <class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot2.html">sigc::slot2</a>< T_return, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1slot2.html">slot2</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot from an arbitrary functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>The desired functor the new slot should be assigned to. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a868deef9d947dfa4fcbb0cfe64cbd42e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a868deef9d947dfa4fcbb0cfe64cbd42e">◆ </a></span>slot2() <span class="overload">[3/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot2.html">sigc::slot2</a>< T_return, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1slot2.html">slot2</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot2.html">slot2</a>< T_return, T_arg1, T_arg2 > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, copying an existing one. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a4719ba9494f87e682b6a6d04b02413e7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4719ba9494f87e682b6a6d04b02413e7">◆ </a></span>slot2() <span class="overload">[4/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot2.html">sigc::slot2</a>< T_return, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1slot2.html">slot2</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot2.html">slot2</a>< T_return, T_arg1, T_arg2 > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, moving an existing one. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="aa2abda2a910db19bbb7a2a08d867e358"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa2abda2a910db19bbb7a2a08d867e358">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1slot2.html">sigc::slot2</a>< T_return, T_arg1, T_arg2 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot2.html#ae69b03a4119d61a0a521b0ad5ddaae46">arg1_type_</a> </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot2.html#af03b1377bbfcdc742a7c00f4c2c419f7">arg2_type_</a> </td>
+ <td class="paramname"><em>_A_a2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invoke the contained functor unless slot is in blocking state. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a6b3d5de4d2e7a6134cc883b98380caa7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a6b3d5de4d2e7a6134cc883b98380caa7">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot2.html">slot2</a>& <a class="el" href="classsigc_1_1slot2.html">sigc::slot2</a>< T_return, T_arg1, T_arg2 >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot2.html">slot2</a>< T_return, T_arg1, T_arg2 > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a copy from another slot. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to make a copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+<a id="aeda5a84c674376aa0800a0bf876bb5fa"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aeda5a84c674376aa0800a0bf876bb5fa">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot2.html">slot2</a>& <a class="el" href="classsigc_1_1slot2.html">sigc::slot2</a>< T_return, T_arg1, T_arg2 >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot2.html">slot2</a>< T_return, T_arg1, T_arg2 > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a move from another slot. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::slot2< T_return, T_arg1, T_arg2 >" name="sigc::slot2< T_return, T_arg1, T_arg2 >">
+<area shape="rect" id="node1" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="5,155,167,196"/>
+<area shape="rect" id="node4" href="$classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot2 template." alt="" coords="9,244,163,300"/>
+<area shape="rect" id="node2" href="$classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="27,80,145,107"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="16,5,156,32"/>
+</map>
--- /dev/null
+94c37b3f32c77cb0b071414dfb893bbf
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot3.html">slot3</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1slot3.html">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot3.html#ac6791fffc805aa2303713fea377dbaae">arg1_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot3.html">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot3.html#a7390ac1945e87a1e0d172fe266a58d72">arg2_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot3.html">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot3.html#a54a09bfe0dd9c518ec22cc14a7e43a23">arg3_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot3.html">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot3.html#addbe340b1f547308035707236e690e66">operator()</a>(arg1_type_ _A_a1, arg2_type_ _A_a2, arg3_type_ _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1slot3.html">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot3.html#a2ff8f9202019d25ddab688128c504e72">operator=</a>(const slot3 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot3.html">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot3.html#ac40a1cefaf9c356a691dfea6819094b8">operator=</a>(slot3 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot3.html">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">sigc::slot_base::operator=</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">sigc::slot_base::operator=</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot3.html#a69cca26f164c63de6ffa70a3806fb936">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot3.html">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a>(void * parent, void *(* cleanup)(void *)) const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot3.html#ac477d74beed45b2b3e26d19b083147ad">slot3</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot3.html">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot3.html#aeb40907cf0589e97fd541c71e368ad03">slot3</a>(const T_functor & _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1slot3.html">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot3.html#afa87acf0475e178f8d970bf05f84b04b">slot3</a>(const slot3 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot3.html">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot3.html#a74644090c829923a4dda5e09f932d4f9">slot3</a>(slot3 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot3.html">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a>(rep_type * rep) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot3.html">slot3</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1slot3-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__slot.html">Slots</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Converts an arbitrary functor to a unified type which is opaque.
+ <a href="classsigc_1_1slot3.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/slot.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1slot3__inherit__graph.png" border="0" usemap="#asigc_1_1slot3_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1slot3_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_01_4_inherit__map" id="asigc_1_1slot3_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_01_4_inherit__map">
+<area shape="rect" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="5,155,195,196"/>
+<area shape="rect" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot3 template." alt="" coords="11,244,189,300"/>
+<area shape="rect" href="classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="41,80,159,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="30,5,170,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:ac6791fffc805aa2303713fea377dbaae"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot3.html#ac6791fffc805aa2303713fea377dbaae">arg1_type_</a></td></tr>
+<tr class="separator:ac6791fffc805aa2303713fea377dbaae"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7390ac1945e87a1e0d172fe266a58d72"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot3.html#a7390ac1945e87a1e0d172fe266a58d72">arg2_type_</a></td></tr>
+<tr class="separator:a7390ac1945e87a1e0d172fe266a58d72"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a54a09bfe0dd9c518ec22cc14a7e43a23"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot3.html#a54a09bfe0dd9c518ec22cc14a7e43a23">arg3_type_</a></td></tr>
+<tr class="separator:a54a09bfe0dd9c518ec22cc14a7e43a23"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a69cca26f164c63de6ffa70a3806fb936"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot3.html#a69cca26f164c63de6ffa70a3806fb936">result_type</a></td></tr>
+<tr class="separator:a69cca26f164c63de6ffa70a3806fb936"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">trackable::func_destroy_notify</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a></td></tr>
+<tr class="separator:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:ac477d74beed45b2b3e26d19b083147ad"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot3.html#ac477d74beed45b2b3e26d19b083147ad">slot3</a> ()</td></tr>
+<tr class="separator:ac477d74beed45b2b3e26d19b083147ad"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa87acf0475e178f8d970bf05f84b04b"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot3.html#afa87acf0475e178f8d970bf05f84b04b">slot3</a> (const <a class="el" href="classsigc_1_1slot3.html">slot3</a> & src)</td></tr>
+<tr class="memdesc:afa87acf0475e178f8d970bf05f84b04b"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot3.html#afa87acf0475e178f8d970bf05f84b04b">More...</a><br /></td></tr>
+<tr class="separator:afa87acf0475e178f8d970bf05f84b04b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aeb40907cf0589e97fd541c71e368ad03"><td class="memTemplParams" colspan="2">template<class T_functor > </td></tr>
+<tr class="memitem:aeb40907cf0589e97fd541c71e368ad03"><td class="memTemplItemLeft" align="right" valign="top"> </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot3.html#aeb40907cf0589e97fd541c71e368ad03">slot3</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:aeb40907cf0589e97fd541c71e368ad03"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an arbitrary functor. <a href="classsigc_1_1slot3.html#aeb40907cf0589e97fd541c71e368ad03">More...</a><br /></td></tr>
+<tr class="separator:aeb40907cf0589e97fd541c71e368ad03"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a74644090c829923a4dda5e09f932d4f9"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot3.html#a74644090c829923a4dda5e09f932d4f9">slot3</a> (<a class="el" href="classsigc_1_1slot3.html">slot3</a> && src)</td></tr>
+<tr class="memdesc:a74644090c829923a4dda5e09f932d4f9"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot3.html#a74644090c829923a4dda5e09f932d4f9">More...</a><br /></td></tr>
+<tr class="separator:a74644090c829923a4dda5e09f932d4f9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:addbe340b1f547308035707236e690e66"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot3.html#addbe340b1f547308035707236e690e66">operator()</a> (<a class="el" href="classsigc_1_1slot3.html#ac6791fffc805aa2303713fea377dbaae">arg1_type_</a> _A_a1, <a class="el" href="classsigc_1_1slot3.html#a7390ac1945e87a1e0d172fe266a58d72">arg2_type_</a> _A_a2, <a class="el" href="classsigc_1_1slot3.html#a54a09bfe0dd9c518ec22cc14a7e43a23">arg3_type_</a> _A_a3) const</td></tr>
+<tr class="memdesc:addbe340b1f547308035707236e690e66"><td class="mdescLeft"> </td><td class="mdescRight">Invoke the contained functor unless slot is in blocking state. <a href="classsigc_1_1slot3.html#addbe340b1f547308035707236e690e66">More...</a><br /></td></tr>
+<tr class="separator:addbe340b1f547308035707236e690e66"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2ff8f9202019d25ddab688128c504e72"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot3.html">slot3</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot3.html#a2ff8f9202019d25ddab688128c504e72">operator=</a> (const <a class="el" href="classsigc_1_1slot3.html">slot3</a> & src)</td></tr>
+<tr class="memdesc:a2ff8f9202019d25ddab688128c504e72"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot3.html#a2ff8f9202019d25ddab688128c504e72">More...</a><br /></td></tr>
+<tr class="separator:a2ff8f9202019d25ddab688128c504e72"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac40a1cefaf9c356a691dfea6819094b8"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot3.html">slot3</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot3.html#ac40a1cefaf9c356a691dfea6819094b8">operator=</a> (<a class="el" href="classsigc_1_1slot3.html">slot3</a> && src)</td></tr>
+<tr class="memdesc:ac40a1cefaf9c356a691dfea6819094b8"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot3.html#ac40a1cefaf9c356a691dfea6819094b8">More...</a><br /></td></tr>
+<tr class="separator:ac40a1cefaf9c356a691dfea6819094b8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a> () noexcept</td></tr>
+<tr class="memdesc:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an empty slot. <a href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">More...</a><br /></td></tr>
+<tr class="separator:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">More...</a><br /></td></tr>
+<tr class="separator:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a> (rep_type * rep) noexcept</td></tr>
+<tr class="memdesc:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an existing slot_rep object. <a href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">More...</a><br /></td></tr>
+<tr class="separator:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">More...</a><br /></td></tr>
+<tr class="separator:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a> ()</td></tr>
+<tr class="separator:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the slot is detroyed. <a href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">More...</a><br /></td></tr>
+<tr class="separator:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state. <a href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">More...</a><br /></td></tr>
+<tr class="separator:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">More...</a><br /></td></tr>
+<tr class="separator:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a> ()</td></tr>
+<tr class="memdesc:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Disconnects the slot. <a href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">More...</a><br /></td></tr>
+<tr class="separator:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is invalid. <a href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">More...</a><br /></td></tr>
+<tr class="separator:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a> () const noexcept</td></tr>
+<tr class="memdesc:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Tests whether a slot is null, because the default constructor was used. <a href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">More...</a><br /></td></tr>
+<tr class="separator:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">operator=</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">More...</a><br /></td></tr>
+<tr class="separator:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">operator=</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">More...</a><br /></td></tr>
+<tr class="separator:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694" title="Add a callback that is executed (notified) when the slot is detroyed.">add_destroy_notify_callback()</a>. <a href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">More...</a><br /></td></tr>
+<tr class="separator:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a> (void * parent, void *(* cleanup)(void *)) const noexcept</td></tr>
+<tr class="memdesc:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the parent of this slot. <a href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">More...</a><br /></td></tr>
+<tr class="separator:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state. <a href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">More...</a><br /></td></tr>
+<tr class="separator:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_attribs_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td></tr>
+<tr class="memdesc:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Indicates whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">More...</a><br /></td></tr>
+<tr class="separator:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">rep_type * </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td></tr>
+<tr class="memdesc:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Typed slot_rep object that contains a functor. <a href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">More...</a><br /></td></tr>
+<tr class="separator:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3><br />
+class sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></h3>
+
+<p>Converts an arbitrary functor to a unified type which is opaque. </p>
+<p><a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> itself is a functor or to be more precise a closure. It contains a single, arbitrary functor (or closure) that is executed in <a class="el" href="classsigc_1_1slot3.html#addbe340b1f547308035707236e690e66" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>.</p>
+<p>The template arguments determine the function signature of <a class="el" href="classsigc_1_1slot3.html#addbe340b1f547308035707236e690e66" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>:</p><ul>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1slot3.html#addbe340b1f547308035707236e690e66" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>.</li>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot3.html#addbe340b1f547308035707236e690e66" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot3.html#addbe340b1f547308035707236e690e66" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot3.html#addbe340b1f547308035707236e690e66" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+</ul>
+<p>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. <a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9" title="Sets the blocking state.">block()</a> and <a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d" title="Unsets the blocking state.">unblock()</a> can be used to block the functor's invocation from <a class="el" href="classsigc_1_1slot3.html#addbe340b1f547308035707236e690e66" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a> temporarily.</p>
+<p>You should use the more convenient unnumbered <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> template. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="ac6791fffc805aa2303713fea377dbaae"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac6791fffc805aa2303713fea377dbaae">◆ </a></span>arg1_type_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg1> <a class="el" href="classsigc_1_1slot3.html">sigc::slot3</a>< T_return, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1slot3.html#ac6791fffc805aa2303713fea377dbaae">arg1_type_</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a7390ac1945e87a1e0d172fe266a58d72"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7390ac1945e87a1e0d172fe266a58d72">◆ </a></span>arg2_type_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg2> <a class="el" href="classsigc_1_1slot3.html">sigc::slot3</a>< T_return, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1slot3.html#a7390ac1945e87a1e0d172fe266a58d72">arg2_type_</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a54a09bfe0dd9c518ec22cc14a7e43a23"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a54a09bfe0dd9c518ec22cc14a7e43a23">◆ </a></span>arg3_type_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg3> <a class="el" href="classsigc_1_1slot3.html">sigc::slot3</a>< T_return, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1slot3.html#a54a09bfe0dd9c518ec22cc14a7e43a23">arg3_type_</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a69cca26f164c63de6ffa70a3806fb936"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a69cca26f164c63de6ffa70a3806fb936">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1slot3.html">sigc::slot3</a>< T_return, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1slot3.html#a69cca26f164c63de6ffa70a3806fb936">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="ac477d74beed45b2b3e26d19b083147ad"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac477d74beed45b2b3e26d19b083147ad">◆ </a></span>slot3() <span class="overload">[1/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot3.html">sigc::slot3</a>< T_return, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1slot3.html">slot3</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aeb40907cf0589e97fd541c71e368ad03"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aeb40907cf0589e97fd541c71e368ad03">◆ </a></span>slot3() <span class="overload">[2/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<div class="memtemplate">
+template <class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot3.html">sigc::slot3</a>< T_return, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1slot3.html">slot3</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot from an arbitrary functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>The desired functor the new slot should be assigned to. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="afa87acf0475e178f8d970bf05f84b04b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#afa87acf0475e178f8d970bf05f84b04b">◆ </a></span>slot3() <span class="overload">[3/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot3.html">sigc::slot3</a>< T_return, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1slot3.html">slot3</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot3.html">slot3</a>< T_return, T_arg1, T_arg2, T_arg3 > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, copying an existing one. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a74644090c829923a4dda5e09f932d4f9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a74644090c829923a4dda5e09f932d4f9">◆ </a></span>slot3() <span class="overload">[4/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot3.html">sigc::slot3</a>< T_return, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1slot3.html">slot3</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot3.html">slot3</a>< T_return, T_arg1, T_arg2, T_arg3 > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, moving an existing one. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="addbe340b1f547308035707236e690e66"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#addbe340b1f547308035707236e690e66">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1slot3.html">sigc::slot3</a>< T_return, T_arg1, T_arg2, T_arg3 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot3.html#ac6791fffc805aa2303713fea377dbaae">arg1_type_</a> </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot3.html#a7390ac1945e87a1e0d172fe266a58d72">arg2_type_</a> </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot3.html#a54a09bfe0dd9c518ec22cc14a7e43a23">arg3_type_</a> </td>
+ <td class="paramname"><em>_A_a3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invoke the contained functor unless slot is in blocking state. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a2ff8f9202019d25ddab688128c504e72"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2ff8f9202019d25ddab688128c504e72">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot3.html">slot3</a>& <a class="el" href="classsigc_1_1slot3.html">sigc::slot3</a>< T_return, T_arg1, T_arg2, T_arg3 >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot3.html">slot3</a>< T_return, T_arg1, T_arg2, T_arg3 > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a copy from another slot. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to make a copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+<a id="ac40a1cefaf9c356a691dfea6819094b8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac40a1cefaf9c356a691dfea6819094b8">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot3.html">slot3</a>& <a class="el" href="classsigc_1_1slot3.html">sigc::slot3</a>< T_return, T_arg1, T_arg2, T_arg3 >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot3.html">slot3</a>< T_return, T_arg1, T_arg2, T_arg3 > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a move from another slot. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 >" name="sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 >">
+<area shape="rect" id="node1" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="5,155,195,196"/>
+<area shape="rect" id="node4" href="$classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot3 template." alt="" coords="11,244,189,300"/>
+<area shape="rect" id="node2" href="$classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="41,80,159,107"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="30,5,170,32"/>
+</map>
--- /dev/null
+3184ac8c53dd8567463bf747a470ec6d
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot4.html">slot4</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1slot4.html">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot4.html#a4426d0dcf517d0d815d6add3c9490437">arg1_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot4.html#abf1d276525f0120a734b2b054b9cfb3f">arg2_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot4.html#ae1af3fbe3981779b68f5676f46f6085c">arg3_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot4.html#aec7f4747dbe5b581c65c07033ca1bfe5">arg4_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot4.html#a02b0d861a47418b9dbf73ab7db67b0a9">operator()</a>(arg1_type_ _A_a1, arg2_type_ _A_a2, arg3_type_ _A_a3, arg4_type_ _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot4.html#ac2fb7f8ae312ced5b7436f0a0d062132">operator=</a>(const slot4 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot4.html#ad05b8c996262ab1bcac89d8c8004a0b5">operator=</a>(slot4 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">sigc::slot_base::operator=</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">sigc::slot_base::operator=</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot4.html#a3f6b5b11385536c1c199ca29468c638a">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a>(void * parent, void *(* cleanup)(void *)) const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot4.html#a4b8ef0494eea86c0d787486ce121db91">slot4</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot4.html#a50d331d378ba1f3cb03f39a42a4aa3cf">slot4</a>(const T_functor & _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot4.html#a7b7080168e769cdec8d916f71fa58d21">slot4</a>(const slot4 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot4.html#acf9e9b169fddb40079618f870172f535">slot4</a>(slot4 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a>(rep_type * rep) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot4.html">slot4</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1slot4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__slot.html">Slots</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Converts an arbitrary functor to a unified type which is opaque.
+ <a href="classsigc_1_1slot4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/slot.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1slot4__inherit__graph.png" border="0" usemap="#asigc_1_1slot4_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1slot4_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_01_4_inherit__map" id="asigc_1_1slot4_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_01_4_inherit__map">
+<area shape="rect" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="5,155,184,211"/>
+<area shape="rect" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot4 template." alt="" coords="5,259,184,315"/>
+<area shape="rect" href="classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="35,80,154,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="25,5,165,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a4426d0dcf517d0d815d6add3c9490437"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot4.html#a4426d0dcf517d0d815d6add3c9490437">arg1_type_</a></td></tr>
+<tr class="separator:a4426d0dcf517d0d815d6add3c9490437"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abf1d276525f0120a734b2b054b9cfb3f"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot4.html#abf1d276525f0120a734b2b054b9cfb3f">arg2_type_</a></td></tr>
+<tr class="separator:abf1d276525f0120a734b2b054b9cfb3f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae1af3fbe3981779b68f5676f46f6085c"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot4.html#ae1af3fbe3981779b68f5676f46f6085c">arg3_type_</a></td></tr>
+<tr class="separator:ae1af3fbe3981779b68f5676f46f6085c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aec7f4747dbe5b581c65c07033ca1bfe5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot4.html#aec7f4747dbe5b581c65c07033ca1bfe5">arg4_type_</a></td></tr>
+<tr class="separator:aec7f4747dbe5b581c65c07033ca1bfe5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3f6b5b11385536c1c199ca29468c638a"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot4.html#a3f6b5b11385536c1c199ca29468c638a">result_type</a></td></tr>
+<tr class="separator:a3f6b5b11385536c1c199ca29468c638a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">trackable::func_destroy_notify</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a></td></tr>
+<tr class="separator:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a4b8ef0494eea86c0d787486ce121db91"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot4.html#a4b8ef0494eea86c0d787486ce121db91">slot4</a> ()</td></tr>
+<tr class="separator:a4b8ef0494eea86c0d787486ce121db91"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7b7080168e769cdec8d916f71fa58d21"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot4.html#a7b7080168e769cdec8d916f71fa58d21">slot4</a> (const <a class="el" href="classsigc_1_1slot4.html">slot4</a> & src)</td></tr>
+<tr class="memdesc:a7b7080168e769cdec8d916f71fa58d21"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot4.html#a7b7080168e769cdec8d916f71fa58d21">More...</a><br /></td></tr>
+<tr class="separator:a7b7080168e769cdec8d916f71fa58d21"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50d331d378ba1f3cb03f39a42a4aa3cf"><td class="memTemplParams" colspan="2">template<class T_functor > </td></tr>
+<tr class="memitem:a50d331d378ba1f3cb03f39a42a4aa3cf"><td class="memTemplItemLeft" align="right" valign="top"> </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot4.html#a50d331d378ba1f3cb03f39a42a4aa3cf">slot4</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:a50d331d378ba1f3cb03f39a42a4aa3cf"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an arbitrary functor. <a href="classsigc_1_1slot4.html#a50d331d378ba1f3cb03f39a42a4aa3cf">More...</a><br /></td></tr>
+<tr class="separator:a50d331d378ba1f3cb03f39a42a4aa3cf"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acf9e9b169fddb40079618f870172f535"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot4.html#acf9e9b169fddb40079618f870172f535">slot4</a> (<a class="el" href="classsigc_1_1slot4.html">slot4</a> && src)</td></tr>
+<tr class="memdesc:acf9e9b169fddb40079618f870172f535"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot4.html#acf9e9b169fddb40079618f870172f535">More...</a><br /></td></tr>
+<tr class="separator:acf9e9b169fddb40079618f870172f535"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a02b0d861a47418b9dbf73ab7db67b0a9"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot4.html#a02b0d861a47418b9dbf73ab7db67b0a9">operator()</a> (<a class="el" href="classsigc_1_1slot4.html#a4426d0dcf517d0d815d6add3c9490437">arg1_type_</a> _A_a1, <a class="el" href="classsigc_1_1slot4.html#abf1d276525f0120a734b2b054b9cfb3f">arg2_type_</a> _A_a2, <a class="el" href="classsigc_1_1slot4.html#ae1af3fbe3981779b68f5676f46f6085c">arg3_type_</a> _A_a3, <a class="el" href="classsigc_1_1slot4.html#aec7f4747dbe5b581c65c07033ca1bfe5">arg4_type_</a> _A_a4) const</td></tr>
+<tr class="memdesc:a02b0d861a47418b9dbf73ab7db67b0a9"><td class="mdescLeft"> </td><td class="mdescRight">Invoke the contained functor unless slot is in blocking state. <a href="classsigc_1_1slot4.html#a02b0d861a47418b9dbf73ab7db67b0a9">More...</a><br /></td></tr>
+<tr class="separator:a02b0d861a47418b9dbf73ab7db67b0a9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac2fb7f8ae312ced5b7436f0a0d062132"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot4.html">slot4</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot4.html#ac2fb7f8ae312ced5b7436f0a0d062132">operator=</a> (const <a class="el" href="classsigc_1_1slot4.html">slot4</a> & src)</td></tr>
+<tr class="memdesc:ac2fb7f8ae312ced5b7436f0a0d062132"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot4.html#ac2fb7f8ae312ced5b7436f0a0d062132">More...</a><br /></td></tr>
+<tr class="separator:ac2fb7f8ae312ced5b7436f0a0d062132"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad05b8c996262ab1bcac89d8c8004a0b5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot4.html">slot4</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot4.html#ad05b8c996262ab1bcac89d8c8004a0b5">operator=</a> (<a class="el" href="classsigc_1_1slot4.html">slot4</a> && src)</td></tr>
+<tr class="memdesc:ad05b8c996262ab1bcac89d8c8004a0b5"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot4.html#ad05b8c996262ab1bcac89d8c8004a0b5">More...</a><br /></td></tr>
+<tr class="separator:ad05b8c996262ab1bcac89d8c8004a0b5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a> () noexcept</td></tr>
+<tr class="memdesc:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an empty slot. <a href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">More...</a><br /></td></tr>
+<tr class="separator:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">More...</a><br /></td></tr>
+<tr class="separator:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a> (rep_type * rep) noexcept</td></tr>
+<tr class="memdesc:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an existing slot_rep object. <a href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">More...</a><br /></td></tr>
+<tr class="separator:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">More...</a><br /></td></tr>
+<tr class="separator:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a> ()</td></tr>
+<tr class="separator:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the slot is detroyed. <a href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">More...</a><br /></td></tr>
+<tr class="separator:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state. <a href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">More...</a><br /></td></tr>
+<tr class="separator:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">More...</a><br /></td></tr>
+<tr class="separator:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a> ()</td></tr>
+<tr class="memdesc:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Disconnects the slot. <a href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">More...</a><br /></td></tr>
+<tr class="separator:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is invalid. <a href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">More...</a><br /></td></tr>
+<tr class="separator:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a> () const noexcept</td></tr>
+<tr class="memdesc:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Tests whether a slot is null, because the default constructor was used. <a href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">More...</a><br /></td></tr>
+<tr class="separator:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">operator=</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">More...</a><br /></td></tr>
+<tr class="separator:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">operator=</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">More...</a><br /></td></tr>
+<tr class="separator:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694" title="Add a callback that is executed (notified) when the slot is detroyed.">add_destroy_notify_callback()</a>. <a href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">More...</a><br /></td></tr>
+<tr class="separator:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a> (void * parent, void *(* cleanup)(void *)) const noexcept</td></tr>
+<tr class="memdesc:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the parent of this slot. <a href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">More...</a><br /></td></tr>
+<tr class="separator:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state. <a href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">More...</a><br /></td></tr>
+<tr class="separator:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_attribs_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td></tr>
+<tr class="memdesc:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Indicates whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">More...</a><br /></td></tr>
+<tr class="separator:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">rep_type * </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td></tr>
+<tr class="memdesc:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Typed slot_rep object that contains a functor. <a href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">More...</a><br /></td></tr>
+<tr class="separator:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4><br />
+class sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></h3>
+
+<p>Converts an arbitrary functor to a unified type which is opaque. </p>
+<p><a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> itself is a functor or to be more precise a closure. It contains a single, arbitrary functor (or closure) that is executed in <a class="el" href="classsigc_1_1slot4.html#a02b0d861a47418b9dbf73ab7db67b0a9" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>.</p>
+<p>The template arguments determine the function signature of <a class="el" href="classsigc_1_1slot4.html#a02b0d861a47418b9dbf73ab7db67b0a9" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>:</p><ul>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1slot4.html#a02b0d861a47418b9dbf73ab7db67b0a9" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>.</li>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot4.html#a02b0d861a47418b9dbf73ab7db67b0a9" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot4.html#a02b0d861a47418b9dbf73ab7db67b0a9" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot4.html#a02b0d861a47418b9dbf73ab7db67b0a9" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot4.html#a02b0d861a47418b9dbf73ab7db67b0a9" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+</ul>
+<p>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. <a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9" title="Sets the blocking state.">block()</a> and <a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d" title="Unsets the blocking state.">unblock()</a> can be used to block the functor's invocation from <a class="el" href="classsigc_1_1slot4.html#a02b0d861a47418b9dbf73ab7db67b0a9" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a> temporarily.</p>
+<p>You should use the more convenient unnumbered <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> template. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a4426d0dcf517d0d815d6add3c9490437"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4426d0dcf517d0d815d6add3c9490437">◆ </a></span>arg1_type_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg1> <a class="el" href="classsigc_1_1slot4.html">sigc::slot4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1slot4.html#a4426d0dcf517d0d815d6add3c9490437">arg1_type_</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="abf1d276525f0120a734b2b054b9cfb3f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abf1d276525f0120a734b2b054b9cfb3f">◆ </a></span>arg2_type_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg2> <a class="el" href="classsigc_1_1slot4.html">sigc::slot4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1slot4.html#abf1d276525f0120a734b2b054b9cfb3f">arg2_type_</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ae1af3fbe3981779b68f5676f46f6085c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae1af3fbe3981779b68f5676f46f6085c">◆ </a></span>arg3_type_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg3> <a class="el" href="classsigc_1_1slot4.html">sigc::slot4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1slot4.html#ae1af3fbe3981779b68f5676f46f6085c">arg3_type_</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aec7f4747dbe5b581c65c07033ca1bfe5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aec7f4747dbe5b581c65c07033ca1bfe5">◆ </a></span>arg4_type_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg4> <a class="el" href="classsigc_1_1slot4.html">sigc::slot4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1slot4.html#aec7f4747dbe5b581c65c07033ca1bfe5">arg4_type_</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a3f6b5b11385536c1c199ca29468c638a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3f6b5b11385536c1c199ca29468c638a">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1slot4.html">sigc::slot4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1slot4.html#a3f6b5b11385536c1c199ca29468c638a">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a4b8ef0494eea86c0d787486ce121db91"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4b8ef0494eea86c0d787486ce121db91">◆ </a></span>slot4() <span class="overload">[1/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1slot4.html">slot4</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a50d331d378ba1f3cb03f39a42a4aa3cf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a50d331d378ba1f3cb03f39a42a4aa3cf">◆ </a></span>slot4() <span class="overload">[2/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<div class="memtemplate">
+template <class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1slot4.html">slot4</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot from an arbitrary functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>The desired functor the new slot should be assigned to. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a7b7080168e769cdec8d916f71fa58d21"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7b7080168e769cdec8d916f71fa58d21">◆ </a></span>slot4() <span class="overload">[3/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1slot4.html">slot4</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot4.html">slot4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4 > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, copying an existing one. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="acf9e9b169fddb40079618f870172f535"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#acf9e9b169fddb40079618f870172f535">◆ </a></span>slot4() <span class="overload">[4/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1slot4.html">slot4</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot4.html">slot4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4 > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, moving an existing one. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a02b0d861a47418b9dbf73ab7db67b0a9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a02b0d861a47418b9dbf73ab7db67b0a9">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1slot4.html">sigc::slot4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot4.html#a4426d0dcf517d0d815d6add3c9490437">arg1_type_</a> </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot4.html#abf1d276525f0120a734b2b054b9cfb3f">arg2_type_</a> </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot4.html#ae1af3fbe3981779b68f5676f46f6085c">arg3_type_</a> </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot4.html#aec7f4747dbe5b581c65c07033ca1bfe5">arg4_type_</a> </td>
+ <td class="paramname"><em>_A_a4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invoke the contained functor unless slot is in blocking state. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="ac2fb7f8ae312ced5b7436f0a0d062132"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac2fb7f8ae312ced5b7436f0a0d062132">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot4.html">slot4</a>& <a class="el" href="classsigc_1_1slot4.html">sigc::slot4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4 >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot4.html">slot4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4 > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a copy from another slot. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to make a copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+<a id="ad05b8c996262ab1bcac89d8c8004a0b5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad05b8c996262ab1bcac89d8c8004a0b5">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot4.html">slot4</a>& <a class="el" href="classsigc_1_1slot4.html">sigc::slot4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4 >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot4.html">slot4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4 > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a move from another slot. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 >" name="sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 >">
+<area shape="rect" id="node1" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="5,155,184,211"/>
+<area shape="rect" id="node4" href="$classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot4 template." alt="" coords="5,259,184,315"/>
+<area shape="rect" id="node2" href="$classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="35,80,154,107"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="25,5,165,32"/>
+</map>
--- /dev/null
+420437f0beb8dbd5ff37138026b580e8
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot5.html">slot5</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot5.html#aeda4706cbac7cb87a276ffeb8bdada16">arg1_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot5.html#ad93d2b3cdce1c3990bde0f49693096e1">arg2_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot5.html#aab17d4f2a38e02219c1a4757ba268baf">arg3_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot5.html#afe7fd46dc4b01397db2c2a9c70b02735">arg4_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot5.html#ade67aef04bbfd7c6af63e93afc709321">arg5_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot5.html#a3f2d9fa2c9747d6c7fc329213446c71d">operator()</a>(arg1_type_ _A_a1, arg2_type_ _A_a2, arg3_type_ _A_a3, arg4_type_ _A_a4, arg5_type_ _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot5.html#a24d22be7be827080b34109c625bad7fd">operator=</a>(const slot5 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot5.html#af000284699d7f5594599f6e742f64e4a">operator=</a>(slot5 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">sigc::slot_base::operator=</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">sigc::slot_base::operator=</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot5.html#aac50a6486dddcac3a42022a6f2189f09">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a>(void * parent, void *(* cleanup)(void *)) const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot5.html#a7548f0d175acd8296064c9bc6d76ea88">slot5</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot5.html#abcf315edb57a1a23ab7f4a0d25e57736">slot5</a>(const T_functor & _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot5.html#ad54fd2ef5f50844c214f1a5fbaef9299">slot5</a>(const slot5 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot5.html#a9c7dc2f187084d174ea9f834178d491d">slot5</a>(slot5 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a>(rep_type * rep) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot5.html">slot5</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1slot5-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__slot.html">Slots</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Converts an arbitrary functor to a unified type which is opaque.
+ <a href="classsigc_1_1slot5.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/slot.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1slot5__inherit__graph.png" border="0" usemap="#asigc_1_1slot5_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1slot5_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_01_4_inherit__map" id="asigc_1_1slot5_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_01_4_inherit__map">
+<area shape="rect" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="9,155,187,211"/>
+<area shape="rect" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot5 template." alt="" coords="5,259,191,315"/>
+<area shape="rect" href="classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="39,80,157,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="28,5,168,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:aeda4706cbac7cb87a276ffeb8bdada16"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot5.html#aeda4706cbac7cb87a276ffeb8bdada16">arg1_type_</a></td></tr>
+<tr class="separator:aeda4706cbac7cb87a276ffeb8bdada16"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad93d2b3cdce1c3990bde0f49693096e1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot5.html#ad93d2b3cdce1c3990bde0f49693096e1">arg2_type_</a></td></tr>
+<tr class="separator:ad93d2b3cdce1c3990bde0f49693096e1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aab17d4f2a38e02219c1a4757ba268baf"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot5.html#aab17d4f2a38e02219c1a4757ba268baf">arg3_type_</a></td></tr>
+<tr class="separator:aab17d4f2a38e02219c1a4757ba268baf"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afe7fd46dc4b01397db2c2a9c70b02735"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot5.html#afe7fd46dc4b01397db2c2a9c70b02735">arg4_type_</a></td></tr>
+<tr class="separator:afe7fd46dc4b01397db2c2a9c70b02735"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ade67aef04bbfd7c6af63e93afc709321"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot5.html#ade67aef04bbfd7c6af63e93afc709321">arg5_type_</a></td></tr>
+<tr class="separator:ade67aef04bbfd7c6af63e93afc709321"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aac50a6486dddcac3a42022a6f2189f09"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot5.html#aac50a6486dddcac3a42022a6f2189f09">result_type</a></td></tr>
+<tr class="separator:aac50a6486dddcac3a42022a6f2189f09"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">trackable::func_destroy_notify</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a></td></tr>
+<tr class="separator:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a7548f0d175acd8296064c9bc6d76ea88"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot5.html#a7548f0d175acd8296064c9bc6d76ea88">slot5</a> ()</td></tr>
+<tr class="separator:a7548f0d175acd8296064c9bc6d76ea88"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad54fd2ef5f50844c214f1a5fbaef9299"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot5.html#ad54fd2ef5f50844c214f1a5fbaef9299">slot5</a> (const <a class="el" href="classsigc_1_1slot5.html">slot5</a> & src)</td></tr>
+<tr class="memdesc:ad54fd2ef5f50844c214f1a5fbaef9299"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot5.html#ad54fd2ef5f50844c214f1a5fbaef9299">More...</a><br /></td></tr>
+<tr class="separator:ad54fd2ef5f50844c214f1a5fbaef9299"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abcf315edb57a1a23ab7f4a0d25e57736"><td class="memTemplParams" colspan="2">template<class T_functor > </td></tr>
+<tr class="memitem:abcf315edb57a1a23ab7f4a0d25e57736"><td class="memTemplItemLeft" align="right" valign="top"> </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot5.html#abcf315edb57a1a23ab7f4a0d25e57736">slot5</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:abcf315edb57a1a23ab7f4a0d25e57736"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an arbitrary functor. <a href="classsigc_1_1slot5.html#abcf315edb57a1a23ab7f4a0d25e57736">More...</a><br /></td></tr>
+<tr class="separator:abcf315edb57a1a23ab7f4a0d25e57736"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9c7dc2f187084d174ea9f834178d491d"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot5.html#a9c7dc2f187084d174ea9f834178d491d">slot5</a> (<a class="el" href="classsigc_1_1slot5.html">slot5</a> && src)</td></tr>
+<tr class="memdesc:a9c7dc2f187084d174ea9f834178d491d"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot5.html#a9c7dc2f187084d174ea9f834178d491d">More...</a><br /></td></tr>
+<tr class="separator:a9c7dc2f187084d174ea9f834178d491d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3f2d9fa2c9747d6c7fc329213446c71d"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot5.html#a3f2d9fa2c9747d6c7fc329213446c71d">operator()</a> (<a class="el" href="classsigc_1_1slot5.html#aeda4706cbac7cb87a276ffeb8bdada16">arg1_type_</a> _A_a1, <a class="el" href="classsigc_1_1slot5.html#ad93d2b3cdce1c3990bde0f49693096e1">arg2_type_</a> _A_a2, <a class="el" href="classsigc_1_1slot5.html#aab17d4f2a38e02219c1a4757ba268baf">arg3_type_</a> _A_a3, <a class="el" href="classsigc_1_1slot5.html#afe7fd46dc4b01397db2c2a9c70b02735">arg4_type_</a> _A_a4, <a class="el" href="classsigc_1_1slot5.html#ade67aef04bbfd7c6af63e93afc709321">arg5_type_</a> _A_a5) const</td></tr>
+<tr class="memdesc:a3f2d9fa2c9747d6c7fc329213446c71d"><td class="mdescLeft"> </td><td class="mdescRight">Invoke the contained functor unless slot is in blocking state. <a href="classsigc_1_1slot5.html#a3f2d9fa2c9747d6c7fc329213446c71d">More...</a><br /></td></tr>
+<tr class="separator:a3f2d9fa2c9747d6c7fc329213446c71d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24d22be7be827080b34109c625bad7fd"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot5.html">slot5</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot5.html#a24d22be7be827080b34109c625bad7fd">operator=</a> (const <a class="el" href="classsigc_1_1slot5.html">slot5</a> & src)</td></tr>
+<tr class="memdesc:a24d22be7be827080b34109c625bad7fd"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot5.html#a24d22be7be827080b34109c625bad7fd">More...</a><br /></td></tr>
+<tr class="separator:a24d22be7be827080b34109c625bad7fd"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af000284699d7f5594599f6e742f64e4a"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot5.html">slot5</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot5.html#af000284699d7f5594599f6e742f64e4a">operator=</a> (<a class="el" href="classsigc_1_1slot5.html">slot5</a> && src)</td></tr>
+<tr class="memdesc:af000284699d7f5594599f6e742f64e4a"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot5.html#af000284699d7f5594599f6e742f64e4a">More...</a><br /></td></tr>
+<tr class="separator:af000284699d7f5594599f6e742f64e4a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a> () noexcept</td></tr>
+<tr class="memdesc:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an empty slot. <a href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">More...</a><br /></td></tr>
+<tr class="separator:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">More...</a><br /></td></tr>
+<tr class="separator:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a> (rep_type * rep) noexcept</td></tr>
+<tr class="memdesc:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an existing slot_rep object. <a href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">More...</a><br /></td></tr>
+<tr class="separator:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">More...</a><br /></td></tr>
+<tr class="separator:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a> ()</td></tr>
+<tr class="separator:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the slot is detroyed. <a href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">More...</a><br /></td></tr>
+<tr class="separator:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state. <a href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">More...</a><br /></td></tr>
+<tr class="separator:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">More...</a><br /></td></tr>
+<tr class="separator:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a> ()</td></tr>
+<tr class="memdesc:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Disconnects the slot. <a href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">More...</a><br /></td></tr>
+<tr class="separator:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is invalid. <a href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">More...</a><br /></td></tr>
+<tr class="separator:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a> () const noexcept</td></tr>
+<tr class="memdesc:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Tests whether a slot is null, because the default constructor was used. <a href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">More...</a><br /></td></tr>
+<tr class="separator:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">operator=</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">More...</a><br /></td></tr>
+<tr class="separator:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">operator=</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">More...</a><br /></td></tr>
+<tr class="separator:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694" title="Add a callback that is executed (notified) when the slot is detroyed.">add_destroy_notify_callback()</a>. <a href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">More...</a><br /></td></tr>
+<tr class="separator:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a> (void * parent, void *(* cleanup)(void *)) const noexcept</td></tr>
+<tr class="memdesc:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the parent of this slot. <a href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">More...</a><br /></td></tr>
+<tr class="separator:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state. <a href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">More...</a><br /></td></tr>
+<tr class="separator:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_attribs_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td></tr>
+<tr class="memdesc:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Indicates whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">More...</a><br /></td></tr>
+<tr class="separator:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">rep_type * </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td></tr>
+<tr class="memdesc:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Typed slot_rep object that contains a functor. <a href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">More...</a><br /></td></tr>
+<tr class="separator:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5><br />
+class sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></h3>
+
+<p>Converts an arbitrary functor to a unified type which is opaque. </p>
+<p><a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> itself is a functor or to be more precise a closure. It contains a single, arbitrary functor (or closure) that is executed in <a class="el" href="classsigc_1_1slot5.html#a3f2d9fa2c9747d6c7fc329213446c71d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>.</p>
+<p>The template arguments determine the function signature of <a class="el" href="classsigc_1_1slot5.html#a3f2d9fa2c9747d6c7fc329213446c71d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>:</p><ul>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1slot5.html#a3f2d9fa2c9747d6c7fc329213446c71d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>.</li>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot5.html#a3f2d9fa2c9747d6c7fc329213446c71d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot5.html#a3f2d9fa2c9747d6c7fc329213446c71d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot5.html#a3f2d9fa2c9747d6c7fc329213446c71d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot5.html#a3f2d9fa2c9747d6c7fc329213446c71d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot5.html#a3f2d9fa2c9747d6c7fc329213446c71d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+</ul>
+<p>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. <a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9" title="Sets the blocking state.">block()</a> and <a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d" title="Unsets the blocking state.">unblock()</a> can be used to block the functor's invocation from <a class="el" href="classsigc_1_1slot5.html#a3f2d9fa2c9747d6c7fc329213446c71d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a> temporarily.</p>
+<p>You should use the more convenient unnumbered <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> template. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="aeda4706cbac7cb87a276ffeb8bdada16"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aeda4706cbac7cb87a276ffeb8bdada16">◆ </a></span>arg1_type_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg1> <a class="el" href="classsigc_1_1slot5.html">sigc::slot5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1slot5.html#aeda4706cbac7cb87a276ffeb8bdada16">arg1_type_</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ad93d2b3cdce1c3990bde0f49693096e1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad93d2b3cdce1c3990bde0f49693096e1">◆ </a></span>arg2_type_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg2> <a class="el" href="classsigc_1_1slot5.html">sigc::slot5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1slot5.html#ad93d2b3cdce1c3990bde0f49693096e1">arg2_type_</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aab17d4f2a38e02219c1a4757ba268baf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aab17d4f2a38e02219c1a4757ba268baf">◆ </a></span>arg3_type_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg3> <a class="el" href="classsigc_1_1slot5.html">sigc::slot5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1slot5.html#aab17d4f2a38e02219c1a4757ba268baf">arg3_type_</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="afe7fd46dc4b01397db2c2a9c70b02735"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#afe7fd46dc4b01397db2c2a9c70b02735">◆ </a></span>arg4_type_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg4> <a class="el" href="classsigc_1_1slot5.html">sigc::slot5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1slot5.html#afe7fd46dc4b01397db2c2a9c70b02735">arg4_type_</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ade67aef04bbfd7c6af63e93afc709321"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ade67aef04bbfd7c6af63e93afc709321">◆ </a></span>arg5_type_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg5> <a class="el" href="classsigc_1_1slot5.html">sigc::slot5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1slot5.html#ade67aef04bbfd7c6af63e93afc709321">arg5_type_</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aac50a6486dddcac3a42022a6f2189f09"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aac50a6486dddcac3a42022a6f2189f09">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1slot5.html">sigc::slot5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1slot5.html#aac50a6486dddcac3a42022a6f2189f09">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a7548f0d175acd8296064c9bc6d76ea88"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7548f0d175acd8296064c9bc6d76ea88">◆ </a></span>slot5() <span class="overload">[1/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1slot5.html">slot5</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="abcf315edb57a1a23ab7f4a0d25e57736"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abcf315edb57a1a23ab7f4a0d25e57736">◆ </a></span>slot5() <span class="overload">[2/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<div class="memtemplate">
+template <class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1slot5.html">slot5</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot from an arbitrary functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>The desired functor the new slot should be assigned to. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="ad54fd2ef5f50844c214f1a5fbaef9299"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad54fd2ef5f50844c214f1a5fbaef9299">◆ </a></span>slot5() <span class="overload">[3/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1slot5.html">slot5</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot5.html">slot5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, copying an existing one. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a9c7dc2f187084d174ea9f834178d491d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9c7dc2f187084d174ea9f834178d491d">◆ </a></span>slot5() <span class="overload">[4/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1slot5.html">slot5</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot5.html">slot5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, moving an existing one. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a3f2d9fa2c9747d6c7fc329213446c71d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3f2d9fa2c9747d6c7fc329213446c71d">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1slot5.html">sigc::slot5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot5.html#aeda4706cbac7cb87a276ffeb8bdada16">arg1_type_</a> </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot5.html#ad93d2b3cdce1c3990bde0f49693096e1">arg2_type_</a> </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot5.html#aab17d4f2a38e02219c1a4757ba268baf">arg3_type_</a> </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot5.html#afe7fd46dc4b01397db2c2a9c70b02735">arg4_type_</a> </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot5.html#ade67aef04bbfd7c6af63e93afc709321">arg5_type_</a> </td>
+ <td class="paramname"><em>_A_a5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invoke the contained functor unless slot is in blocking state. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a24d22be7be827080b34109c625bad7fd"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a24d22be7be827080b34109c625bad7fd">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot5.html">slot5</a>& <a class="el" href="classsigc_1_1slot5.html">sigc::slot5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot5.html">slot5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a copy from another slot. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to make a copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+<a id="af000284699d7f5594599f6e742f64e4a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af000284699d7f5594599f6e742f64e4a">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot5.html">slot5</a>& <a class="el" href="classsigc_1_1slot5.html">sigc::slot5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot5.html">slot5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a move from another slot. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >" name="sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >">
+<area shape="rect" id="node1" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="9,155,187,211"/>
+<area shape="rect" id="node4" href="$classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot5 template." alt="" coords="5,259,191,315"/>
+<area shape="rect" id="node2" href="$classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="39,80,157,107"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="28,5,168,32"/>
+</map>
--- /dev/null
+4e3fd364a68b77f2d049032f8b1e0cef
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot6.html">slot6</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot6.html#a98240591834da17569f94410684120ba">arg1_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot6.html#a44b34c5068d0150922cc630400a1962a">arg2_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot6.html#a05f153d441986f23d115bf29c92736ca">arg3_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot6.html#a285a8d86913eff1b27b89f4d795190c1">arg4_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot6.html#a4a304a22b1a1fae56b7998ae4ae3c0e1">arg5_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot6.html#ae935d9ad4042e4cfb0730e2855d7882e">arg6_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot6.html#ac2d6449f2928138c434c474050c7c192">operator()</a>(arg1_type_ _A_a1, arg2_type_ _A_a2, arg3_type_ _A_a3, arg4_type_ _A_a4, arg5_type_ _A_a5, arg6_type_ _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot6.html#a7d13ed520a19d287719bd24050b7d8a2">operator=</a>(const slot6 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot6.html#a078ab12d6b08bd132041b4787f99ea85">operator=</a>(slot6 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">sigc::slot_base::operator=</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">sigc::slot_base::operator=</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot6.html#a8dae48d6160e0f917f545eb10950a9bf">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a>(void * parent, void *(* cleanup)(void *)) const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot6.html#a3c763adcaa8b9c34c808ef0f15b1fc48">slot6</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot6.html#a7458f98cd4ed4a9aa6671ea9f0c260f2">slot6</a>(const T_functor & _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot6.html#a7e4c0f209961d3797f6fadfe9d1c6078">slot6</a>(const slot6 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot6.html#af7132887ca029e0325d46baa2026bea4">slot6</a>(slot6 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a>(rep_type * rep) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot6.html">slot6</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1slot6-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__slot.html">Slots</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Converts an arbitrary functor to a unified type which is opaque.
+ <a href="classsigc_1_1slot6.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/slot.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1slot6__inherit__graph.png" border="0" usemap="#asigc_1_1slot6_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1slot6_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_01_4_inherit__map" id="asigc_1_1slot6_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_01_4_inherit__map">
+<area shape="rect" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="17,155,207,211"/>
+<area shape="rect" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot6 template." alt="" coords="5,259,219,315"/>
+<area shape="rect" href="classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="53,80,171,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="42,5,182,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a98240591834da17569f94410684120ba"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html#a98240591834da17569f94410684120ba">arg1_type_</a></td></tr>
+<tr class="separator:a98240591834da17569f94410684120ba"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a44b34c5068d0150922cc630400a1962a"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html#a44b34c5068d0150922cc630400a1962a">arg2_type_</a></td></tr>
+<tr class="separator:a44b34c5068d0150922cc630400a1962a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a05f153d441986f23d115bf29c92736ca"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html#a05f153d441986f23d115bf29c92736ca">arg3_type_</a></td></tr>
+<tr class="separator:a05f153d441986f23d115bf29c92736ca"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a285a8d86913eff1b27b89f4d795190c1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html#a285a8d86913eff1b27b89f4d795190c1">arg4_type_</a></td></tr>
+<tr class="separator:a285a8d86913eff1b27b89f4d795190c1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4a304a22b1a1fae56b7998ae4ae3c0e1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html#a4a304a22b1a1fae56b7998ae4ae3c0e1">arg5_type_</a></td></tr>
+<tr class="separator:a4a304a22b1a1fae56b7998ae4ae3c0e1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae935d9ad4042e4cfb0730e2855d7882e"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html#ae935d9ad4042e4cfb0730e2855d7882e">arg6_type_</a></td></tr>
+<tr class="separator:ae935d9ad4042e4cfb0730e2855d7882e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8dae48d6160e0f917f545eb10950a9bf"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html#a8dae48d6160e0f917f545eb10950a9bf">result_type</a></td></tr>
+<tr class="separator:a8dae48d6160e0f917f545eb10950a9bf"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">trackable::func_destroy_notify</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a></td></tr>
+<tr class="separator:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a3c763adcaa8b9c34c808ef0f15b1fc48"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html#a3c763adcaa8b9c34c808ef0f15b1fc48">slot6</a> ()</td></tr>
+<tr class="separator:a3c763adcaa8b9c34c808ef0f15b1fc48"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7e4c0f209961d3797f6fadfe9d1c6078"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html#a7e4c0f209961d3797f6fadfe9d1c6078">slot6</a> (const <a class="el" href="classsigc_1_1slot6.html">slot6</a> & src)</td></tr>
+<tr class="memdesc:a7e4c0f209961d3797f6fadfe9d1c6078"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot6.html#a7e4c0f209961d3797f6fadfe9d1c6078">More...</a><br /></td></tr>
+<tr class="separator:a7e4c0f209961d3797f6fadfe9d1c6078"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7458f98cd4ed4a9aa6671ea9f0c260f2"><td class="memTemplParams" colspan="2">template<class T_functor > </td></tr>
+<tr class="memitem:a7458f98cd4ed4a9aa6671ea9f0c260f2"><td class="memTemplItemLeft" align="right" valign="top"> </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html#a7458f98cd4ed4a9aa6671ea9f0c260f2">slot6</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:a7458f98cd4ed4a9aa6671ea9f0c260f2"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an arbitrary functor. <a href="classsigc_1_1slot6.html#a7458f98cd4ed4a9aa6671ea9f0c260f2">More...</a><br /></td></tr>
+<tr class="separator:a7458f98cd4ed4a9aa6671ea9f0c260f2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af7132887ca029e0325d46baa2026bea4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html#af7132887ca029e0325d46baa2026bea4">slot6</a> (<a class="el" href="classsigc_1_1slot6.html">slot6</a> && src)</td></tr>
+<tr class="memdesc:af7132887ca029e0325d46baa2026bea4"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot6.html#af7132887ca029e0325d46baa2026bea4">More...</a><br /></td></tr>
+<tr class="separator:af7132887ca029e0325d46baa2026bea4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac2d6449f2928138c434c474050c7c192"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html#ac2d6449f2928138c434c474050c7c192">operator()</a> (<a class="el" href="classsigc_1_1slot6.html#a98240591834da17569f94410684120ba">arg1_type_</a> _A_a1, <a class="el" href="classsigc_1_1slot6.html#a44b34c5068d0150922cc630400a1962a">arg2_type_</a> _A_a2, <a class="el" href="classsigc_1_1slot6.html#a05f153d441986f23d115bf29c92736ca">arg3_type_</a> _A_a3, <a class="el" href="classsigc_1_1slot6.html#a285a8d86913eff1b27b89f4d795190c1">arg4_type_</a> _A_a4, <a class="el" href="classsigc_1_1slot6.html#a4a304a22b1a1fae56b7998ae4ae3c0e1">arg5_type_</a> _A_a5, <a class="el" href="classsigc_1_1slot6.html#ae935d9ad4042e4cfb0730e2855d7882e">arg6_type_</a> _A_a6) const</td></tr>
+<tr class="memdesc:ac2d6449f2928138c434c474050c7c192"><td class="mdescLeft"> </td><td class="mdescRight">Invoke the contained functor unless slot is in blocking state. <a href="classsigc_1_1slot6.html#ac2d6449f2928138c434c474050c7c192">More...</a><br /></td></tr>
+<tr class="separator:ac2d6449f2928138c434c474050c7c192"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7d13ed520a19d287719bd24050b7d8a2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot6.html">slot6</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html#a7d13ed520a19d287719bd24050b7d8a2">operator=</a> (const <a class="el" href="classsigc_1_1slot6.html">slot6</a> & src)</td></tr>
+<tr class="memdesc:a7d13ed520a19d287719bd24050b7d8a2"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot6.html#a7d13ed520a19d287719bd24050b7d8a2">More...</a><br /></td></tr>
+<tr class="separator:a7d13ed520a19d287719bd24050b7d8a2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a078ab12d6b08bd132041b4787f99ea85"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot6.html">slot6</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html#a078ab12d6b08bd132041b4787f99ea85">operator=</a> (<a class="el" href="classsigc_1_1slot6.html">slot6</a> && src)</td></tr>
+<tr class="memdesc:a078ab12d6b08bd132041b4787f99ea85"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot6.html#a078ab12d6b08bd132041b4787f99ea85">More...</a><br /></td></tr>
+<tr class="separator:a078ab12d6b08bd132041b4787f99ea85"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a> () noexcept</td></tr>
+<tr class="memdesc:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an empty slot. <a href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">More...</a><br /></td></tr>
+<tr class="separator:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">More...</a><br /></td></tr>
+<tr class="separator:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a> (rep_type * rep) noexcept</td></tr>
+<tr class="memdesc:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an existing slot_rep object. <a href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">More...</a><br /></td></tr>
+<tr class="separator:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">More...</a><br /></td></tr>
+<tr class="separator:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a> ()</td></tr>
+<tr class="separator:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the slot is detroyed. <a href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">More...</a><br /></td></tr>
+<tr class="separator:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state. <a href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">More...</a><br /></td></tr>
+<tr class="separator:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">More...</a><br /></td></tr>
+<tr class="separator:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a> ()</td></tr>
+<tr class="memdesc:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Disconnects the slot. <a href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">More...</a><br /></td></tr>
+<tr class="separator:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is invalid. <a href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">More...</a><br /></td></tr>
+<tr class="separator:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a> () const noexcept</td></tr>
+<tr class="memdesc:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Tests whether a slot is null, because the default constructor was used. <a href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">More...</a><br /></td></tr>
+<tr class="separator:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">operator=</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">More...</a><br /></td></tr>
+<tr class="separator:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">operator=</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">More...</a><br /></td></tr>
+<tr class="separator:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694" title="Add a callback that is executed (notified) when the slot is detroyed.">add_destroy_notify_callback()</a>. <a href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">More...</a><br /></td></tr>
+<tr class="separator:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a> (void * parent, void *(* cleanup)(void *)) const noexcept</td></tr>
+<tr class="memdesc:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the parent of this slot. <a href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">More...</a><br /></td></tr>
+<tr class="separator:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state. <a href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">More...</a><br /></td></tr>
+<tr class="separator:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_attribs_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td></tr>
+<tr class="memdesc:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Indicates whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">More...</a><br /></td></tr>
+<tr class="separator:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">rep_type * </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td></tr>
+<tr class="memdesc:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Typed slot_rep object that contains a functor. <a href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">More...</a><br /></td></tr>
+<tr class="separator:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6><br />
+class sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></h3>
+
+<p>Converts an arbitrary functor to a unified type which is opaque. </p>
+<p><a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> itself is a functor or to be more precise a closure. It contains a single, arbitrary functor (or closure) that is executed in <a class="el" href="classsigc_1_1slot6.html#ac2d6449f2928138c434c474050c7c192" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>.</p>
+<p>The template arguments determine the function signature of <a class="el" href="classsigc_1_1slot6.html#ac2d6449f2928138c434c474050c7c192" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>:</p><ul>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1slot6.html#ac2d6449f2928138c434c474050c7c192" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>.</li>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot6.html#ac2d6449f2928138c434c474050c7c192" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot6.html#ac2d6449f2928138c434c474050c7c192" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot6.html#ac2d6449f2928138c434c474050c7c192" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot6.html#ac2d6449f2928138c434c474050c7c192" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot6.html#ac2d6449f2928138c434c474050c7c192" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg6</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot6.html#ac2d6449f2928138c434c474050c7c192" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+</ul>
+<p>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. <a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9" title="Sets the blocking state.">block()</a> and <a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d" title="Unsets the blocking state.">unblock()</a> can be used to block the functor's invocation from <a class="el" href="classsigc_1_1slot6.html#ac2d6449f2928138c434c474050c7c192" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a> temporarily.</p>
+<p>You should use the more convenient unnumbered <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> template. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a98240591834da17569f94410684120ba"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a98240591834da17569f94410684120ba">◆ </a></span>arg1_type_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg1> <a class="el" href="classsigc_1_1slot6.html">sigc::slot6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1slot6.html#a98240591834da17569f94410684120ba">arg1_type_</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a44b34c5068d0150922cc630400a1962a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a44b34c5068d0150922cc630400a1962a">◆ </a></span>arg2_type_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg2> <a class="el" href="classsigc_1_1slot6.html">sigc::slot6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1slot6.html#a44b34c5068d0150922cc630400a1962a">arg2_type_</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a05f153d441986f23d115bf29c92736ca"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a05f153d441986f23d115bf29c92736ca">◆ </a></span>arg3_type_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg3> <a class="el" href="classsigc_1_1slot6.html">sigc::slot6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1slot6.html#a05f153d441986f23d115bf29c92736ca">arg3_type_</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a285a8d86913eff1b27b89f4d795190c1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a285a8d86913eff1b27b89f4d795190c1">◆ </a></span>arg4_type_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg4> <a class="el" href="classsigc_1_1slot6.html">sigc::slot6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1slot6.html#a285a8d86913eff1b27b89f4d795190c1">arg4_type_</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a4a304a22b1a1fae56b7998ae4ae3c0e1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4a304a22b1a1fae56b7998ae4ae3c0e1">◆ </a></span>arg5_type_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg5> <a class="el" href="classsigc_1_1slot6.html">sigc::slot6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1slot6.html#a4a304a22b1a1fae56b7998ae4ae3c0e1">arg5_type_</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ae935d9ad4042e4cfb0730e2855d7882e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae935d9ad4042e4cfb0730e2855d7882e">◆ </a></span>arg6_type_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg6> <a class="el" href="classsigc_1_1slot6.html">sigc::slot6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1slot6.html#ae935d9ad4042e4cfb0730e2855d7882e">arg6_type_</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a8dae48d6160e0f917f545eb10950a9bf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8dae48d6160e0f917f545eb10950a9bf">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1slot6.html">sigc::slot6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1slot6.html#a8dae48d6160e0f917f545eb10950a9bf">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a3c763adcaa8b9c34c808ef0f15b1fc48"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3c763adcaa8b9c34c808ef0f15b1fc48">◆ </a></span>slot6() <span class="overload">[1/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1slot6.html">slot6</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a7458f98cd4ed4a9aa6671ea9f0c260f2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7458f98cd4ed4a9aa6671ea9f0c260f2">◆ </a></span>slot6() <span class="overload">[2/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<div class="memtemplate">
+template <class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1slot6.html">slot6</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot from an arbitrary functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>The desired functor the new slot should be assigned to. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a7e4c0f209961d3797f6fadfe9d1c6078"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7e4c0f209961d3797f6fadfe9d1c6078">◆ </a></span>slot6() <span class="overload">[3/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1slot6.html">slot6</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot6.html">slot6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, copying an existing one. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="af7132887ca029e0325d46baa2026bea4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af7132887ca029e0325d46baa2026bea4">◆ </a></span>slot6() <span class="overload">[4/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1slot6.html">slot6</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot6.html">slot6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, moving an existing one. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="ac2d6449f2928138c434c474050c7c192"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac2d6449f2928138c434c474050c7c192">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1slot6.html">sigc::slot6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot6.html#a98240591834da17569f94410684120ba">arg1_type_</a> </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot6.html#a44b34c5068d0150922cc630400a1962a">arg2_type_</a> </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot6.html#a05f153d441986f23d115bf29c92736ca">arg3_type_</a> </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot6.html#a285a8d86913eff1b27b89f4d795190c1">arg4_type_</a> </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot6.html#a4a304a22b1a1fae56b7998ae4ae3c0e1">arg5_type_</a> </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot6.html#ae935d9ad4042e4cfb0730e2855d7882e">arg6_type_</a> </td>
+ <td class="paramname"><em>_A_a6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invoke the contained functor unless slot is in blocking state. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a7d13ed520a19d287719bd24050b7d8a2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7d13ed520a19d287719bd24050b7d8a2">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot6.html">slot6</a>& <a class="el" href="classsigc_1_1slot6.html">sigc::slot6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot6.html">slot6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a copy from another slot. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to make a copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+<a id="a078ab12d6b08bd132041b4787f99ea85"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a078ab12d6b08bd132041b4787f99ea85">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot6.html">slot6</a>& <a class="el" href="classsigc_1_1slot6.html">sigc::slot6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot6.html">slot6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a move from another slot. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >" name="sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >">
+<area shape="rect" id="node1" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="17,155,207,211"/>
+<area shape="rect" id="node4" href="$classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot6 template." alt="" coords="5,259,219,315"/>
+<area shape="rect" id="node2" href="$classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="53,80,171,107"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="42,5,182,32"/>
+</map>
--- /dev/null
+743c42c968418e29f3e505cc7bcae54a
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot7.html">slot7</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot7.html#a58edf93a837003d1a69fc77d39fc11a9">arg1_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot7.html#ad144d8ea3ecb891d358b5b1b969be7e2">arg2_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot7.html#af90cd5954008a84d6459d99de152a08c">arg3_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot7.html#af42bc9af248b7c2226d93230bd7b1024">arg4_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot7.html#ad6c1006a29f6fcb721bc39e8d6f82323">arg5_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot7.html#ae25a8a8663addfce52415a20725a3b3e">arg6_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot7.html#a2dc6c96b8d014fab9daea823188ca021">arg7_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d">operator()</a>(arg1_type_ _A_a1, arg2_type_ _A_a2, arg3_type_ _A_a3, arg4_type_ _A_a4, arg5_type_ _A_a5, arg6_type_ _A_a6, arg7_type_ _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot7.html#af6bf09a0b3c09245257af113e70269d2">operator=</a>(const slot7 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot7.html#a82b499c48909c51c4dad097885804638">operator=</a>(slot7 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">sigc::slot_base::operator=</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">sigc::slot_base::operator=</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot7.html#a06a374d3304636cb48fed29542dc851f">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a>(void * parent, void *(* cleanup)(void *)) const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot7.html#abf200ae4152fb26fc96a6863be3548b8">slot7</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot7.html#aa9b64dc6516b8a0d55f46e4737eaaf8b">slot7</a>(const T_functor & _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot7.html#a6411349bb6f8d7151f41ae7772e61f6d">slot7</a>(const slot7 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot7.html#a69a267bb61931f4ea039048d3221517c">slot7</a>(slot7 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a>(rep_type * rep) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot7.html">slot7</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1slot7-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__slot.html">Slots</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Converts an arbitrary functor to a unified type which is opaque.
+ <a href="classsigc_1_1slot7.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/slot.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1slot7__inherit__graph.png" border="0" usemap="#asigc_1_1slot7_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1slot7_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map" id="asigc_1_1slot7_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map">
+<area shape="rect" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="5,155,184,225"/>
+<area shape="rect" href="classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="35,80,154,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="25,5,165,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a58edf93a837003d1a69fc77d39fc11a9"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#a58edf93a837003d1a69fc77d39fc11a9">arg1_type_</a></td></tr>
+<tr class="separator:a58edf93a837003d1a69fc77d39fc11a9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad144d8ea3ecb891d358b5b1b969be7e2"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#ad144d8ea3ecb891d358b5b1b969be7e2">arg2_type_</a></td></tr>
+<tr class="separator:ad144d8ea3ecb891d358b5b1b969be7e2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af90cd5954008a84d6459d99de152a08c"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#af90cd5954008a84d6459d99de152a08c">arg3_type_</a></td></tr>
+<tr class="separator:af90cd5954008a84d6459d99de152a08c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af42bc9af248b7c2226d93230bd7b1024"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#af42bc9af248b7c2226d93230bd7b1024">arg4_type_</a></td></tr>
+<tr class="separator:af42bc9af248b7c2226d93230bd7b1024"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad6c1006a29f6fcb721bc39e8d6f82323"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#ad6c1006a29f6fcb721bc39e8d6f82323">arg5_type_</a></td></tr>
+<tr class="separator:ad6c1006a29f6fcb721bc39e8d6f82323"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae25a8a8663addfce52415a20725a3b3e"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#ae25a8a8663addfce52415a20725a3b3e">arg6_type_</a></td></tr>
+<tr class="separator:ae25a8a8663addfce52415a20725a3b3e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2dc6c96b8d014fab9daea823188ca021"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#a2dc6c96b8d014fab9daea823188ca021">arg7_type_</a></td></tr>
+<tr class="separator:a2dc6c96b8d014fab9daea823188ca021"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a06a374d3304636cb48fed29542dc851f"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#a06a374d3304636cb48fed29542dc851f">result_type</a></td></tr>
+<tr class="separator:a06a374d3304636cb48fed29542dc851f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">trackable::func_destroy_notify</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a></td></tr>
+<tr class="separator:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:abf200ae4152fb26fc96a6863be3548b8"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#abf200ae4152fb26fc96a6863be3548b8">slot7</a> ()</td></tr>
+<tr class="separator:abf200ae4152fb26fc96a6863be3548b8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a6411349bb6f8d7151f41ae7772e61f6d"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#a6411349bb6f8d7151f41ae7772e61f6d">slot7</a> (const <a class="el" href="classsigc_1_1slot7.html">slot7</a> & src)</td></tr>
+<tr class="memdesc:a6411349bb6f8d7151f41ae7772e61f6d"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot7.html#a6411349bb6f8d7151f41ae7772e61f6d">More...</a><br /></td></tr>
+<tr class="separator:a6411349bb6f8d7151f41ae7772e61f6d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa9b64dc6516b8a0d55f46e4737eaaf8b"><td class="memTemplParams" colspan="2">template<class T_functor > </td></tr>
+<tr class="memitem:aa9b64dc6516b8a0d55f46e4737eaaf8b"><td class="memTemplItemLeft" align="right" valign="top"> </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#aa9b64dc6516b8a0d55f46e4737eaaf8b">slot7</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:aa9b64dc6516b8a0d55f46e4737eaaf8b"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an arbitrary functor. <a href="classsigc_1_1slot7.html#aa9b64dc6516b8a0d55f46e4737eaaf8b">More...</a><br /></td></tr>
+<tr class="separator:aa9b64dc6516b8a0d55f46e4737eaaf8b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a69a267bb61931f4ea039048d3221517c"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#a69a267bb61931f4ea039048d3221517c">slot7</a> (<a class="el" href="classsigc_1_1slot7.html">slot7</a> && src)</td></tr>
+<tr class="memdesc:a69a267bb61931f4ea039048d3221517c"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot7.html#a69a267bb61931f4ea039048d3221517c">More...</a><br /></td></tr>
+<tr class="separator:a69a267bb61931f4ea039048d3221517c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a28e18e1a9adc88a4758be7d2497fc88d"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d">operator()</a> (<a class="el" href="classsigc_1_1slot7.html#a58edf93a837003d1a69fc77d39fc11a9">arg1_type_</a> _A_a1, <a class="el" href="classsigc_1_1slot7.html#ad144d8ea3ecb891d358b5b1b969be7e2">arg2_type_</a> _A_a2, <a class="el" href="classsigc_1_1slot7.html#af90cd5954008a84d6459d99de152a08c">arg3_type_</a> _A_a3, <a class="el" href="classsigc_1_1slot7.html#af42bc9af248b7c2226d93230bd7b1024">arg4_type_</a> _A_a4, <a class="el" href="classsigc_1_1slot7.html#ad6c1006a29f6fcb721bc39e8d6f82323">arg5_type_</a> _A_a5, <a class="el" href="classsigc_1_1slot7.html#ae25a8a8663addfce52415a20725a3b3e">arg6_type_</a> _A_a6, <a class="el" href="classsigc_1_1slot7.html#a2dc6c96b8d014fab9daea823188ca021">arg7_type_</a> _A_a7) const</td></tr>
+<tr class="memdesc:a28e18e1a9adc88a4758be7d2497fc88d"><td class="mdescLeft"> </td><td class="mdescRight">Invoke the contained functor unless slot is in blocking state. <a href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d">More...</a><br /></td></tr>
+<tr class="separator:a28e18e1a9adc88a4758be7d2497fc88d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af6bf09a0b3c09245257af113e70269d2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot7.html">slot7</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#af6bf09a0b3c09245257af113e70269d2">operator=</a> (const <a class="el" href="classsigc_1_1slot7.html">slot7</a> & src)</td></tr>
+<tr class="memdesc:af6bf09a0b3c09245257af113e70269d2"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot7.html#af6bf09a0b3c09245257af113e70269d2">More...</a><br /></td></tr>
+<tr class="separator:af6bf09a0b3c09245257af113e70269d2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a82b499c48909c51c4dad097885804638"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot7.html">slot7</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html#a82b499c48909c51c4dad097885804638">operator=</a> (<a class="el" href="classsigc_1_1slot7.html">slot7</a> && src)</td></tr>
+<tr class="memdesc:a82b499c48909c51c4dad097885804638"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot7.html#a82b499c48909c51c4dad097885804638">More...</a><br /></td></tr>
+<tr class="separator:a82b499c48909c51c4dad097885804638"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a> () noexcept</td></tr>
+<tr class="memdesc:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an empty slot. <a href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">More...</a><br /></td></tr>
+<tr class="separator:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">More...</a><br /></td></tr>
+<tr class="separator:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a> (rep_type * rep) noexcept</td></tr>
+<tr class="memdesc:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an existing slot_rep object. <a href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">More...</a><br /></td></tr>
+<tr class="separator:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">More...</a><br /></td></tr>
+<tr class="separator:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a> ()</td></tr>
+<tr class="separator:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the slot is detroyed. <a href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">More...</a><br /></td></tr>
+<tr class="separator:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state. <a href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">More...</a><br /></td></tr>
+<tr class="separator:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">More...</a><br /></td></tr>
+<tr class="separator:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a> ()</td></tr>
+<tr class="memdesc:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Disconnects the slot. <a href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">More...</a><br /></td></tr>
+<tr class="separator:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is invalid. <a href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">More...</a><br /></td></tr>
+<tr class="separator:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a> () const noexcept</td></tr>
+<tr class="memdesc:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Tests whether a slot is null, because the default constructor was used. <a href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">More...</a><br /></td></tr>
+<tr class="separator:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">operator=</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">More...</a><br /></td></tr>
+<tr class="separator:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">operator=</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">More...</a><br /></td></tr>
+<tr class="separator:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694" title="Add a callback that is executed (notified) when the slot is detroyed.">add_destroy_notify_callback()</a>. <a href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">More...</a><br /></td></tr>
+<tr class="separator:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a> (void * parent, void *(* cleanup)(void *)) const noexcept</td></tr>
+<tr class="memdesc:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the parent of this slot. <a href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">More...</a><br /></td></tr>
+<tr class="separator:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state. <a href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">More...</a><br /></td></tr>
+<tr class="separator:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_attribs_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td></tr>
+<tr class="memdesc:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Indicates whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">More...</a><br /></td></tr>
+<tr class="separator:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">rep_type * </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td></tr>
+<tr class="memdesc:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Typed slot_rep object that contains a functor. <a href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">More...</a><br /></td></tr>
+<tr class="separator:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7><br />
+class sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></h3>
+
+<p>Converts an arbitrary functor to a unified type which is opaque. </p>
+<p><a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> itself is a functor or to be more precise a closure. It contains a single, arbitrary functor (or closure) that is executed in <a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>.</p>
+<p>The template arguments determine the function signature of <a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>:</p><ul>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>.</li>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg6</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+<li><em>T_arg7</em> Argument type used in the definition of <a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>. The default <code>nil</code> means no argument.</li>
+</ul>
+<p>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. <a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9" title="Sets the blocking state.">block()</a> and <a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d" title="Unsets the blocking state.">unblock()</a> can be used to block the functor's invocation from <a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a> temporarily.</p>
+<p>You should use the more convenient unnumbered <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> template. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a58edf93a837003d1a69fc77d39fc11a9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a58edf93a837003d1a69fc77d39fc11a9">◆ </a></span>arg1_type_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg1> <a class="el" href="classsigc_1_1slot7.html">sigc::slot7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1slot7.html#a58edf93a837003d1a69fc77d39fc11a9">arg1_type_</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ad144d8ea3ecb891d358b5b1b969be7e2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad144d8ea3ecb891d358b5b1b969be7e2">◆ </a></span>arg2_type_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg2> <a class="el" href="classsigc_1_1slot7.html">sigc::slot7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1slot7.html#ad144d8ea3ecb891d358b5b1b969be7e2">arg2_type_</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="af90cd5954008a84d6459d99de152a08c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af90cd5954008a84d6459d99de152a08c">◆ </a></span>arg3_type_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg3> <a class="el" href="classsigc_1_1slot7.html">sigc::slot7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1slot7.html#af90cd5954008a84d6459d99de152a08c">arg3_type_</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="af42bc9af248b7c2226d93230bd7b1024"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af42bc9af248b7c2226d93230bd7b1024">◆ </a></span>arg4_type_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg4> <a class="el" href="classsigc_1_1slot7.html">sigc::slot7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1slot7.html#af42bc9af248b7c2226d93230bd7b1024">arg4_type_</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ad6c1006a29f6fcb721bc39e8d6f82323"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad6c1006a29f6fcb721bc39e8d6f82323">◆ </a></span>arg5_type_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg5> <a class="el" href="classsigc_1_1slot7.html">sigc::slot7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1slot7.html#ad6c1006a29f6fcb721bc39e8d6f82323">arg5_type_</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ae25a8a8663addfce52415a20725a3b3e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae25a8a8663addfce52415a20725a3b3e">◆ </a></span>arg6_type_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg6> <a class="el" href="classsigc_1_1slot7.html">sigc::slot7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1slot7.html#ae25a8a8663addfce52415a20725a3b3e">arg6_type_</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a2dc6c96b8d014fab9daea823188ca021"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2dc6c96b8d014fab9daea823188ca021">◆ </a></span>arg7_type_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a><T_arg7> <a class="el" href="classsigc_1_1slot7.html">sigc::slot7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1slot7.html#a2dc6c96b8d014fab9daea823188ca021">arg7_type_</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a06a374d3304636cb48fed29542dc851f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a06a374d3304636cb48fed29542dc851f">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1slot7.html">sigc::slot7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1slot7.html#a06a374d3304636cb48fed29542dc851f">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="abf200ae4152fb26fc96a6863be3548b8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abf200ae4152fb26fc96a6863be3548b8">◆ </a></span>slot7() <span class="overload">[1/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1slot7.html">slot7</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aa9b64dc6516b8a0d55f46e4737eaaf8b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa9b64dc6516b8a0d55f46e4737eaaf8b">◆ </a></span>slot7() <span class="overload">[2/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<div class="memtemplate">
+template <class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1slot7.html">slot7</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot from an arbitrary functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>The desired functor the new slot should be assigned to. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a6411349bb6f8d7151f41ae7772e61f6d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a6411349bb6f8d7151f41ae7772e61f6d">◆ </a></span>slot7() <span class="overload">[3/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1slot7.html">slot7</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot7.html">slot7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, copying an existing one. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a69a267bb61931f4ea039048d3221517c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a69a267bb61931f4ea039048d3221517c">◆ </a></span>slot7() <span class="overload">[4/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1slot7.html">slot7</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot7.html">slot7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, moving an existing one. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a28e18e1a9adc88a4758be7d2497fc88d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a28e18e1a9adc88a4758be7d2497fc88d">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1slot7.html">sigc::slot7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot7.html#a58edf93a837003d1a69fc77d39fc11a9">arg1_type_</a> </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot7.html#ad144d8ea3ecb891d358b5b1b969be7e2">arg2_type_</a> </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot7.html#af90cd5954008a84d6459d99de152a08c">arg3_type_</a> </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot7.html#af42bc9af248b7c2226d93230bd7b1024">arg4_type_</a> </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot7.html#ad6c1006a29f6fcb721bc39e8d6f82323">arg5_type_</a> </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot7.html#ae25a8a8663addfce52415a20725a3b3e">arg6_type_</a> </td>
+ <td class="paramname"><em>_A_a6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot7.html#a2dc6c96b8d014fab9daea823188ca021">arg7_type_</a> </td>
+ <td class="paramname"><em>_A_a7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invoke the contained functor unless slot is in blocking state. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a7</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="af6bf09a0b3c09245257af113e70269d2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af6bf09a0b3c09245257af113e70269d2">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot7.html">slot7</a>& <a class="el" href="classsigc_1_1slot7.html">sigc::slot7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot7.html">slot7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a copy from another slot. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to make a copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+<a id="a82b499c48909c51c4dad097885804638"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a82b499c48909c51c4dad097885804638">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot7.html">slot7</a>& <a class="el" href="classsigc_1_1slot7.html">sigc::slot7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot7.html">slot7</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a move from another slot. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >" name="sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >">
+<area shape="rect" id="node1" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="5,155,184,225"/>
+<area shape="rect" id="node2" href="$classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="35,80,154,107"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="25,5,165,32"/>
+</map>
--- /dev/null
+bdb45d0c6e12316e7cfaf4addfb8f45f
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html">slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot6.html#a98240591834da17569f94410684120ba">arg1_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot6.html#a44b34c5068d0150922cc630400a1962a">arg2_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot6.html#a05f153d441986f23d115bf29c92736ca">arg3_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot6.html#a285a8d86913eff1b27b89f4d795190c1">arg4_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot6.html#a4a304a22b1a1fae56b7998ae4ae3c0e1">arg5_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot6.html#ae935d9ad4042e4cfb0730e2855d7882e">arg6_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot6.html#ac2d6449f2928138c434c474050c7c192">operator()</a>(arg1_type_ _A_a1, arg2_type_ _A_a2, arg3_type_ _A_a3, arg4_type_ _A_a4, arg5_type_ _A_a5, arg6_type_ _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a5146567efe93808fbba32c114d2f302e">operator=</a>(const slot & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#ace5ff8e4e75675985f148a3d2af0ce64">operator=</a>(slot && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot6.html#a7d13ed520a19d287719bd24050b7d8a2">sigc::slot6::operator=</a>(const slot6 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot6.html#a078ab12d6b08bd132041b4787f99ea85">sigc::slot6::operator=</a>(slot6 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">sigc::slot_base::operator=</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">sigc::slot_base::operator=</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a9c9028da9fc75a10c6c396673159d471">parent_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot6.html#a8dae48d6160e0f917f545eb10950a9bf">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a>(void * parent, void *(* cleanup)(void *)) const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a290753f903665f059c25a4f71c9a9e16">slot</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#ab3081b23ab4fee6191cd8a2f57ba199d">slot</a>(const T_functor & _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a8be1480e392dcaa57d47e1c2a132edd4">slot</a>(const slot & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a139944017d26e32ec7a347d94a1fc952">slot</a>(slot && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot6.html#a3c763adcaa8b9c34c808ef0f15b1fc48">slot6</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot6.html#a7458f98cd4ed4a9aa6671ea9f0c260f2">slot6</a>(const T_functor & _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot6.html#a7e4c0f209961d3797f6fadfe9d1c6078">slot6</a>(const slot6 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot6.html#af7132887ca029e0325d46baa2026bea4">slot6</a>(slot6 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a>(rep_type * rep) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >" name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::slot6 template." alt="" coords="5,259,219,315"/>
+<area shape="rect" id="node2" href="$classsigc_1_1slot6.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="17,155,207,211"/>
+<area shape="rect" id="node3" href="$classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="53,80,171,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="42,5,182,32"/>
+</map>
--- /dev/null
+2807d97543596dc4d7fa8fee745c98a1
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html">slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg519ed0b830799ecdfb1e59a58e3902913.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot6.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot6</a> template.
+ <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/slot.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg55fd8828cf1e28d31ca1331678509a180.png" border="0" usemap="#asigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4_inherit__map" id="asigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::slot6 template." alt="" coords="5,259,219,315"/>
+<area shape="rect" href="classsigc_1_1slot6.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="17,155,207,211"/>
+<area shape="rect" href="classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="53,80,171,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="42,5,182,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a9c9028da9fc75a10c6c396673159d471"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot6.html">slot6</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a9c9028da9fc75a10c6c396673159d471">parent_type</a></td></tr>
+<tr class="separator:a9c9028da9fc75a10c6c396673159d471"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1slot6"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1slot6')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td></tr>
+<tr class="memitem:a98240591834da17569f94410684120ba inherit pub_types_classsigc_1_1slot6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html#a98240591834da17569f94410684120ba">arg1_type_</a></td></tr>
+<tr class="separator:a98240591834da17569f94410684120ba inherit pub_types_classsigc_1_1slot6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a44b34c5068d0150922cc630400a1962a inherit pub_types_classsigc_1_1slot6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html#a44b34c5068d0150922cc630400a1962a">arg2_type_</a></td></tr>
+<tr class="separator:a44b34c5068d0150922cc630400a1962a inherit pub_types_classsigc_1_1slot6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a05f153d441986f23d115bf29c92736ca inherit pub_types_classsigc_1_1slot6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html#a05f153d441986f23d115bf29c92736ca">arg3_type_</a></td></tr>
+<tr class="separator:a05f153d441986f23d115bf29c92736ca inherit pub_types_classsigc_1_1slot6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a285a8d86913eff1b27b89f4d795190c1 inherit pub_types_classsigc_1_1slot6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html#a285a8d86913eff1b27b89f4d795190c1">arg4_type_</a></td></tr>
+<tr class="separator:a285a8d86913eff1b27b89f4d795190c1 inherit pub_types_classsigc_1_1slot6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4a304a22b1a1fae56b7998ae4ae3c0e1 inherit pub_types_classsigc_1_1slot6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html#a4a304a22b1a1fae56b7998ae4ae3c0e1">arg5_type_</a></td></tr>
+<tr class="separator:a4a304a22b1a1fae56b7998ae4ae3c0e1 inherit pub_types_classsigc_1_1slot6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae935d9ad4042e4cfb0730e2855d7882e inherit pub_types_classsigc_1_1slot6"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html#ae935d9ad4042e4cfb0730e2855d7882e">arg6_type_</a></td></tr>
+<tr class="separator:ae935d9ad4042e4cfb0730e2855d7882e inherit pub_types_classsigc_1_1slot6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8dae48d6160e0f917f545eb10950a9bf inherit pub_types_classsigc_1_1slot6"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html#a8dae48d6160e0f917f545eb10950a9bf">result_type</a></td></tr>
+<tr class="separator:a8dae48d6160e0f917f545eb10950a9bf inherit pub_types_classsigc_1_1slot6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">trackable::func_destroy_notify</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a></td></tr>
+<tr class="separator:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a290753f903665f059c25a4f71c9a9e16"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a290753f903665f059c25a4f71c9a9e16">slot</a> ()</td></tr>
+<tr class="separator:a290753f903665f059c25a4f71c9a9e16"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8be1480e392dcaa57d47e1c2a132edd4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a8be1480e392dcaa57d47e1c2a132edd4">slot</a> (const <a class="el" href="classsigc_1_1slot.html">slot</a> & src)</td></tr>
+<tr class="memdesc:a8be1480e392dcaa57d47e1c2a132edd4"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a8be1480e392dcaa57d47e1c2a132edd4">More...</a><br /></td></tr>
+<tr class="separator:a8be1480e392dcaa57d47e1c2a132edd4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab3081b23ab4fee6191cd8a2f57ba199d"><td class="memTemplParams" colspan="2">template<class T_functor > </td></tr>
+<tr class="memitem:ab3081b23ab4fee6191cd8a2f57ba199d"><td class="memTemplItemLeft" align="right" valign="top"> </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#ab3081b23ab4fee6191cd8a2f57ba199d">slot</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:ab3081b23ab4fee6191cd8a2f57ba199d"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an arbitrary functor. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#ab3081b23ab4fee6191cd8a2f57ba199d">More...</a><br /></td></tr>
+<tr class="separator:ab3081b23ab4fee6191cd8a2f57ba199d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a139944017d26e32ec7a347d94a1fc952"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a139944017d26e32ec7a347d94a1fc952">slot</a> (<a class="el" href="classsigc_1_1slot.html">slot</a> && src)</td></tr>
+<tr class="memdesc:a139944017d26e32ec7a347d94a1fc952"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a139944017d26e32ec7a347d94a1fc952">More...</a><br /></td></tr>
+<tr class="separator:a139944017d26e32ec7a347d94a1fc952"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5146567efe93808fbba32c114d2f302e"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot.html">slot</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a5146567efe93808fbba32c114d2f302e">operator=</a> (const <a class="el" href="classsigc_1_1slot.html">slot</a> & src)</td></tr>
+<tr class="memdesc:a5146567efe93808fbba32c114d2f302e"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a5146567efe93808fbba32c114d2f302e">More...</a><br /></td></tr>
+<tr class="separator:a5146567efe93808fbba32c114d2f302e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ace5ff8e4e75675985f148a3d2af0ce64"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot.html">slot</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#ace5ff8e4e75675985f148a3d2af0ce64">operator=</a> (<a class="el" href="classsigc_1_1slot.html">slot</a> && src)</td></tr>
+<tr class="memdesc:ace5ff8e4e75675985f148a3d2af0ce64"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#ace5ff8e4e75675985f148a3d2af0ce64">More...</a><br /></td></tr>
+<tr class="separator:ace5ff8e4e75675985f148a3d2af0ce64"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1slot6"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1slot6')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td></tr>
+<tr class="memitem:a3c763adcaa8b9c34c808ef0f15b1fc48 inherit pub_methods_classsigc_1_1slot6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html#a3c763adcaa8b9c34c808ef0f15b1fc48">slot6</a> ()</td></tr>
+<tr class="separator:a3c763adcaa8b9c34c808ef0f15b1fc48 inherit pub_methods_classsigc_1_1slot6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7e4c0f209961d3797f6fadfe9d1c6078 inherit pub_methods_classsigc_1_1slot6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html#a7e4c0f209961d3797f6fadfe9d1c6078">slot6</a> (const <a class="el" href="classsigc_1_1slot6.html">slot6</a> & src)</td></tr>
+<tr class="memdesc:a7e4c0f209961d3797f6fadfe9d1c6078 inherit pub_methods_classsigc_1_1slot6"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot6.html#a7e4c0f209961d3797f6fadfe9d1c6078">More...</a><br /></td></tr>
+<tr class="separator:a7e4c0f209961d3797f6fadfe9d1c6078 inherit pub_methods_classsigc_1_1slot6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7458f98cd4ed4a9aa6671ea9f0c260f2 inherit pub_methods_classsigc_1_1slot6"><td class="memTemplParams" colspan="2">template<class T_functor > </td></tr>
+<tr class="memitem:a7458f98cd4ed4a9aa6671ea9f0c260f2 inherit pub_methods_classsigc_1_1slot6"><td class="memTemplItemLeft" align="right" valign="top"> </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html#a7458f98cd4ed4a9aa6671ea9f0c260f2">slot6</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:a7458f98cd4ed4a9aa6671ea9f0c260f2 inherit pub_methods_classsigc_1_1slot6"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an arbitrary functor. <a href="classsigc_1_1slot6.html#a7458f98cd4ed4a9aa6671ea9f0c260f2">More...</a><br /></td></tr>
+<tr class="separator:a7458f98cd4ed4a9aa6671ea9f0c260f2 inherit pub_methods_classsigc_1_1slot6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af7132887ca029e0325d46baa2026bea4 inherit pub_methods_classsigc_1_1slot6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html#af7132887ca029e0325d46baa2026bea4">slot6</a> (<a class="el" href="classsigc_1_1slot6.html">slot6</a> && src)</td></tr>
+<tr class="memdesc:af7132887ca029e0325d46baa2026bea4 inherit pub_methods_classsigc_1_1slot6"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot6.html#af7132887ca029e0325d46baa2026bea4">More...</a><br /></td></tr>
+<tr class="separator:af7132887ca029e0325d46baa2026bea4 inherit pub_methods_classsigc_1_1slot6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac2d6449f2928138c434c474050c7c192 inherit pub_methods_classsigc_1_1slot6"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html#ac2d6449f2928138c434c474050c7c192">operator()</a> (<a class="el" href="classsigc_1_1slot6.html#a98240591834da17569f94410684120ba">arg1_type_</a> _A_a1, <a class="el" href="classsigc_1_1slot6.html#a44b34c5068d0150922cc630400a1962a">arg2_type_</a> _A_a2, <a class="el" href="classsigc_1_1slot6.html#a05f153d441986f23d115bf29c92736ca">arg3_type_</a> _A_a3, <a class="el" href="classsigc_1_1slot6.html#a285a8d86913eff1b27b89f4d795190c1">arg4_type_</a> _A_a4, <a class="el" href="classsigc_1_1slot6.html#a4a304a22b1a1fae56b7998ae4ae3c0e1">arg5_type_</a> _A_a5, <a class="el" href="classsigc_1_1slot6.html#ae935d9ad4042e4cfb0730e2855d7882e">arg6_type_</a> _A_a6) const</td></tr>
+<tr class="memdesc:ac2d6449f2928138c434c474050c7c192 inherit pub_methods_classsigc_1_1slot6"><td class="mdescLeft"> </td><td class="mdescRight">Invoke the contained functor unless slot is in blocking state. <a href="classsigc_1_1slot6.html#ac2d6449f2928138c434c474050c7c192">More...</a><br /></td></tr>
+<tr class="separator:ac2d6449f2928138c434c474050c7c192 inherit pub_methods_classsigc_1_1slot6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7d13ed520a19d287719bd24050b7d8a2 inherit pub_methods_classsigc_1_1slot6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot6.html">slot6</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html#a7d13ed520a19d287719bd24050b7d8a2">operator=</a> (const <a class="el" href="classsigc_1_1slot6.html">slot6</a> & src)</td></tr>
+<tr class="memdesc:a7d13ed520a19d287719bd24050b7d8a2 inherit pub_methods_classsigc_1_1slot6"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot6.html#a7d13ed520a19d287719bd24050b7d8a2">More...</a><br /></td></tr>
+<tr class="separator:a7d13ed520a19d287719bd24050b7d8a2 inherit pub_methods_classsigc_1_1slot6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a078ab12d6b08bd132041b4787f99ea85 inherit pub_methods_classsigc_1_1slot6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot6.html">slot6</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html#a078ab12d6b08bd132041b4787f99ea85">operator=</a> (<a class="el" href="classsigc_1_1slot6.html">slot6</a> && src)</td></tr>
+<tr class="memdesc:a078ab12d6b08bd132041b4787f99ea85 inherit pub_methods_classsigc_1_1slot6"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot6.html#a078ab12d6b08bd132041b4787f99ea85">More...</a><br /></td></tr>
+<tr class="separator:a078ab12d6b08bd132041b4787f99ea85 inherit pub_methods_classsigc_1_1slot6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a> () noexcept</td></tr>
+<tr class="memdesc:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an empty slot. <a href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">More...</a><br /></td></tr>
+<tr class="separator:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">More...</a><br /></td></tr>
+<tr class="separator:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a> (rep_type * rep) noexcept</td></tr>
+<tr class="memdesc:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an existing slot_rep object. <a href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">More...</a><br /></td></tr>
+<tr class="separator:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">More...</a><br /></td></tr>
+<tr class="separator:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a> ()</td></tr>
+<tr class="separator:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the slot is detroyed. <a href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">More...</a><br /></td></tr>
+<tr class="separator:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state. <a href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">More...</a><br /></td></tr>
+<tr class="separator:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">More...</a><br /></td></tr>
+<tr class="separator:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a> ()</td></tr>
+<tr class="memdesc:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Disconnects the slot. <a href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">More...</a><br /></td></tr>
+<tr class="separator:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is invalid. <a href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">More...</a><br /></td></tr>
+<tr class="separator:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a> () const noexcept</td></tr>
+<tr class="memdesc:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Tests whether a slot is null, because the default constructor was used. <a href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">More...</a><br /></td></tr>
+<tr class="separator:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">operator=</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">More...</a><br /></td></tr>
+<tr class="separator:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">operator=</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">More...</a><br /></td></tr>
+<tr class="separator:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694" title="Add a callback that is executed (notified) when the slot is detroyed.">add_destroy_notify_callback()</a>. <a href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">More...</a><br /></td></tr>
+<tr class="separator:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a> (void * parent, void *(* cleanup)(void *)) const noexcept</td></tr>
+<tr class="memdesc:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the parent of this slot. <a href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">More...</a><br /></td></tr>
+<tr class="separator:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state. <a href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">More...</a><br /></td></tr>
+<tr class="separator:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_attribs_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td></tr>
+<tr class="memdesc:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Indicates whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">More...</a><br /></td></tr>
+<tr class="separator:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">rep_type * </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td></tr>
+<tr class="memdesc:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Typed slot_rep object that contains a functor. <a href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">More...</a><br /></td></tr>
+<tr class="separator:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6><br />
+class sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot6.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot6</a> template. </p>
+<p>See the base class for useful methods. This is the template specialization of the unnumbered <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> template for 6 argument(s), specialized for different numbers of arguments This is possible because the template has default (nil) template types.</p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000201">Deprecated:</a></b></dt><dd>Please use the syntax similar to that used by std::function<>: </dd></dl>
+<div class="fragment"><div class="line"><a class="code" href="classsigc_1_1slot.html">sigc::slot</a><void(<span class="keywordtype">bool</span>, <span class="keywordtype">int</span>)> some_slot;</div>
+<div class="ttc" id="aclasssigc_1_1slot_html"><div class="ttname"><a href="classsigc_1_1slot.html">sigc::slot</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::slot# templates.</div><div class="ttdef"><b>Definition:</b> slot.h:1645</div></div>
+</div><!-- fragment --> </div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a9c9028da9fc75a10c6c396673159d471"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9c9028da9fc75a10c6c396673159d471">◆ </a></span>parent_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="classsigc_1_1slot6.html">slot6</a><T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> <a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a9c9028da9fc75a10c6c396673159d471">parent_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a290753f903665f059c25a4f71c9a9e16"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a290753f903665f059c25a4f71c9a9e16">◆ </a></span>slot() <span class="overload">[1/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ab3081b23ab4fee6191cd8a2f57ba199d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab3081b23ab4fee6191cd8a2f57ba199d">◆ </a></span>slot() <span class="overload">[2/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<div class="memtemplate">
+template <class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot from an arbitrary functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>The desired functor the new slot should be assigned to. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a8be1480e392dcaa57d47e1c2a132edd4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8be1480e392dcaa57d47e1c2a132edd4">◆ </a></span>slot() <span class="overload">[3/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, <a class="el" href="structsigc_1_1nil.html">nil</a> > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, copying an existing one. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a139944017d26e32ec7a347d94a1fc952"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a139944017d26e32ec7a347d94a1fc952">◆ </a></span>slot() <span class="overload">[4/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, <a class="el" href="structsigc_1_1nil.html">nil</a> > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, moving an existing one. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a5146567efe93808fbba32c114d2f302e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5146567efe93808fbba32c114d2f302e">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">slot</a>& <a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, <a class="el" href="structsigc_1_1nil.html">nil</a> > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a copy from another slot. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to make a copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+<a id="ace5ff8e4e75675985f148a3d2af0ce64"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ace5ff8e4e75675985f148a3d2af0ce64">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">slot</a>& <a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, <a class="el" href="structsigc_1_1nil.html">nil</a> > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a move from another slot. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html">slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot5.html#aeda4706cbac7cb87a276ffeb8bdada16">arg1_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot5.html#ad93d2b3cdce1c3990bde0f49693096e1">arg2_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot5.html#aab17d4f2a38e02219c1a4757ba268baf">arg3_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot5.html#afe7fd46dc4b01397db2c2a9c70b02735">arg4_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot5.html#ade67aef04bbfd7c6af63e93afc709321">arg5_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot5.html#a3f2d9fa2c9747d6c7fc329213446c71d">operator()</a>(arg1_type_ _A_a1, arg2_type_ _A_a2, arg3_type_ _A_a3, arg4_type_ _A_a4, arg5_type_ _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a3ca127357feda698616f9ed7209653ff">operator=</a>(const slot & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a3195ba5b04503a37525bf2142c704f70">operator=</a>(slot && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot5.html#a24d22be7be827080b34109c625bad7fd">sigc::slot5::operator=</a>(const slot5 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot5.html#af000284699d7f5594599f6e742f64e4a">sigc::slot5::operator=</a>(slot5 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">sigc::slot_base::operator=</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">sigc::slot_base::operator=</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a013f4139332e23166f7db3be6da4ba91">parent_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot5.html#aac50a6486dddcac3a42022a6f2189f09">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a>(void * parent, void *(* cleanup)(void *)) const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a81c9e625279217aee1ae00696927c39e">slot</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a8d5f076fe0207cabd9b2632382bedd89">slot</a>(const T_functor & _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#afab26283085a050db6d75a1bfe273f86">slot</a>(const slot & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#aad4ab45a94e4ec0bddf66c4d88e38b0a">slot</a>(slot && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot5.html#a7548f0d175acd8296064c9bc6d76ea88">slot5</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot5.html#abcf315edb57a1a23ab7f4a0d25e57736">slot5</a>(const T_functor & _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot5.html#ad54fd2ef5f50844c214f1a5fbaef9299">slot5</a>(const slot5 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot5.html#a9c7dc2f187084d174ea9f834178d491d">slot5</a>(slot5 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a>(rep_type * rep) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html">slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot5.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot5</a> template.
+ <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/slot.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5aeb6f23fed93d951563913dc5fa02580.png" border="0" usemap="#asigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4_inherit__map" id="asigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::slot5 template." alt="" coords="5,259,191,315"/>
+<area shape="rect" href="classsigc_1_1slot5.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="9,155,187,211"/>
+<area shape="rect" href="classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="39,80,157,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="28,5,168,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a013f4139332e23166f7db3be6da4ba91"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot5.html">slot5</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a013f4139332e23166f7db3be6da4ba91">parent_type</a></td></tr>
+<tr class="separator:a013f4139332e23166f7db3be6da4ba91"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1slot5"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1slot5')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td></tr>
+<tr class="memitem:aeda4706cbac7cb87a276ffeb8bdada16 inherit pub_types_classsigc_1_1slot5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot5.html#aeda4706cbac7cb87a276ffeb8bdada16">arg1_type_</a></td></tr>
+<tr class="separator:aeda4706cbac7cb87a276ffeb8bdada16 inherit pub_types_classsigc_1_1slot5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad93d2b3cdce1c3990bde0f49693096e1 inherit pub_types_classsigc_1_1slot5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot5.html#ad93d2b3cdce1c3990bde0f49693096e1">arg2_type_</a></td></tr>
+<tr class="separator:ad93d2b3cdce1c3990bde0f49693096e1 inherit pub_types_classsigc_1_1slot5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aab17d4f2a38e02219c1a4757ba268baf inherit pub_types_classsigc_1_1slot5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot5.html#aab17d4f2a38e02219c1a4757ba268baf">arg3_type_</a></td></tr>
+<tr class="separator:aab17d4f2a38e02219c1a4757ba268baf inherit pub_types_classsigc_1_1slot5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afe7fd46dc4b01397db2c2a9c70b02735 inherit pub_types_classsigc_1_1slot5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot5.html#afe7fd46dc4b01397db2c2a9c70b02735">arg4_type_</a></td></tr>
+<tr class="separator:afe7fd46dc4b01397db2c2a9c70b02735 inherit pub_types_classsigc_1_1slot5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ade67aef04bbfd7c6af63e93afc709321 inherit pub_types_classsigc_1_1slot5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot5.html#ade67aef04bbfd7c6af63e93afc709321">arg5_type_</a></td></tr>
+<tr class="separator:ade67aef04bbfd7c6af63e93afc709321 inherit pub_types_classsigc_1_1slot5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aac50a6486dddcac3a42022a6f2189f09 inherit pub_types_classsigc_1_1slot5"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot5.html#aac50a6486dddcac3a42022a6f2189f09">result_type</a></td></tr>
+<tr class="separator:aac50a6486dddcac3a42022a6f2189f09 inherit pub_types_classsigc_1_1slot5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">trackable::func_destroy_notify</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a></td></tr>
+<tr class="separator:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a81c9e625279217aee1ae00696927c39e"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a81c9e625279217aee1ae00696927c39e">slot</a> ()</td></tr>
+<tr class="separator:a81c9e625279217aee1ae00696927c39e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afab26283085a050db6d75a1bfe273f86"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#afab26283085a050db6d75a1bfe273f86">slot</a> (const <a class="el" href="classsigc_1_1slot.html">slot</a> & src)</td></tr>
+<tr class="memdesc:afab26283085a050db6d75a1bfe273f86"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#afab26283085a050db6d75a1bfe273f86">More...</a><br /></td></tr>
+<tr class="separator:afab26283085a050db6d75a1bfe273f86"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8d5f076fe0207cabd9b2632382bedd89"><td class="memTemplParams" colspan="2">template<class T_functor > </td></tr>
+<tr class="memitem:a8d5f076fe0207cabd9b2632382bedd89"><td class="memTemplItemLeft" align="right" valign="top"> </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a8d5f076fe0207cabd9b2632382bedd89">slot</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:a8d5f076fe0207cabd9b2632382bedd89"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an arbitrary functor. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a8d5f076fe0207cabd9b2632382bedd89">More...</a><br /></td></tr>
+<tr class="separator:a8d5f076fe0207cabd9b2632382bedd89"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aad4ab45a94e4ec0bddf66c4d88e38b0a"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#aad4ab45a94e4ec0bddf66c4d88e38b0a">slot</a> (<a class="el" href="classsigc_1_1slot.html">slot</a> && src)</td></tr>
+<tr class="memdesc:aad4ab45a94e4ec0bddf66c4d88e38b0a"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#aad4ab45a94e4ec0bddf66c4d88e38b0a">More...</a><br /></td></tr>
+<tr class="separator:aad4ab45a94e4ec0bddf66c4d88e38b0a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3ca127357feda698616f9ed7209653ff"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot.html">slot</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a3ca127357feda698616f9ed7209653ff">operator=</a> (const <a class="el" href="classsigc_1_1slot.html">slot</a> & src)</td></tr>
+<tr class="memdesc:a3ca127357feda698616f9ed7209653ff"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a3ca127357feda698616f9ed7209653ff">More...</a><br /></td></tr>
+<tr class="separator:a3ca127357feda698616f9ed7209653ff"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3195ba5b04503a37525bf2142c704f70"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot.html">slot</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a3195ba5b04503a37525bf2142c704f70">operator=</a> (<a class="el" href="classsigc_1_1slot.html">slot</a> && src)</td></tr>
+<tr class="memdesc:a3195ba5b04503a37525bf2142c704f70"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a3195ba5b04503a37525bf2142c704f70">More...</a><br /></td></tr>
+<tr class="separator:a3195ba5b04503a37525bf2142c704f70"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1slot5"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1slot5')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td></tr>
+<tr class="memitem:a7548f0d175acd8296064c9bc6d76ea88 inherit pub_methods_classsigc_1_1slot5"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot5.html#a7548f0d175acd8296064c9bc6d76ea88">slot5</a> ()</td></tr>
+<tr class="separator:a7548f0d175acd8296064c9bc6d76ea88 inherit pub_methods_classsigc_1_1slot5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad54fd2ef5f50844c214f1a5fbaef9299 inherit pub_methods_classsigc_1_1slot5"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot5.html#ad54fd2ef5f50844c214f1a5fbaef9299">slot5</a> (const <a class="el" href="classsigc_1_1slot5.html">slot5</a> & src)</td></tr>
+<tr class="memdesc:ad54fd2ef5f50844c214f1a5fbaef9299 inherit pub_methods_classsigc_1_1slot5"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot5.html#ad54fd2ef5f50844c214f1a5fbaef9299">More...</a><br /></td></tr>
+<tr class="separator:ad54fd2ef5f50844c214f1a5fbaef9299 inherit pub_methods_classsigc_1_1slot5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abcf315edb57a1a23ab7f4a0d25e57736 inherit pub_methods_classsigc_1_1slot5"><td class="memTemplParams" colspan="2">template<class T_functor > </td></tr>
+<tr class="memitem:abcf315edb57a1a23ab7f4a0d25e57736 inherit pub_methods_classsigc_1_1slot5"><td class="memTemplItemLeft" align="right" valign="top"> </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot5.html#abcf315edb57a1a23ab7f4a0d25e57736">slot5</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:abcf315edb57a1a23ab7f4a0d25e57736 inherit pub_methods_classsigc_1_1slot5"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an arbitrary functor. <a href="classsigc_1_1slot5.html#abcf315edb57a1a23ab7f4a0d25e57736">More...</a><br /></td></tr>
+<tr class="separator:abcf315edb57a1a23ab7f4a0d25e57736 inherit pub_methods_classsigc_1_1slot5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9c7dc2f187084d174ea9f834178d491d inherit pub_methods_classsigc_1_1slot5"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot5.html#a9c7dc2f187084d174ea9f834178d491d">slot5</a> (<a class="el" href="classsigc_1_1slot5.html">slot5</a> && src)</td></tr>
+<tr class="memdesc:a9c7dc2f187084d174ea9f834178d491d inherit pub_methods_classsigc_1_1slot5"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot5.html#a9c7dc2f187084d174ea9f834178d491d">More...</a><br /></td></tr>
+<tr class="separator:a9c7dc2f187084d174ea9f834178d491d inherit pub_methods_classsigc_1_1slot5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3f2d9fa2c9747d6c7fc329213446c71d inherit pub_methods_classsigc_1_1slot5"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot5.html#a3f2d9fa2c9747d6c7fc329213446c71d">operator()</a> (<a class="el" href="classsigc_1_1slot5.html#aeda4706cbac7cb87a276ffeb8bdada16">arg1_type_</a> _A_a1, <a class="el" href="classsigc_1_1slot5.html#ad93d2b3cdce1c3990bde0f49693096e1">arg2_type_</a> _A_a2, <a class="el" href="classsigc_1_1slot5.html#aab17d4f2a38e02219c1a4757ba268baf">arg3_type_</a> _A_a3, <a class="el" href="classsigc_1_1slot5.html#afe7fd46dc4b01397db2c2a9c70b02735">arg4_type_</a> _A_a4, <a class="el" href="classsigc_1_1slot5.html#ade67aef04bbfd7c6af63e93afc709321">arg5_type_</a> _A_a5) const</td></tr>
+<tr class="memdesc:a3f2d9fa2c9747d6c7fc329213446c71d inherit pub_methods_classsigc_1_1slot5"><td class="mdescLeft"> </td><td class="mdescRight">Invoke the contained functor unless slot is in blocking state. <a href="classsigc_1_1slot5.html#a3f2d9fa2c9747d6c7fc329213446c71d">More...</a><br /></td></tr>
+<tr class="separator:a3f2d9fa2c9747d6c7fc329213446c71d inherit pub_methods_classsigc_1_1slot5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24d22be7be827080b34109c625bad7fd inherit pub_methods_classsigc_1_1slot5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot5.html">slot5</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot5.html#a24d22be7be827080b34109c625bad7fd">operator=</a> (const <a class="el" href="classsigc_1_1slot5.html">slot5</a> & src)</td></tr>
+<tr class="memdesc:a24d22be7be827080b34109c625bad7fd inherit pub_methods_classsigc_1_1slot5"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot5.html#a24d22be7be827080b34109c625bad7fd">More...</a><br /></td></tr>
+<tr class="separator:a24d22be7be827080b34109c625bad7fd inherit pub_methods_classsigc_1_1slot5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af000284699d7f5594599f6e742f64e4a inherit pub_methods_classsigc_1_1slot5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot5.html">slot5</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot5.html#af000284699d7f5594599f6e742f64e4a">operator=</a> (<a class="el" href="classsigc_1_1slot5.html">slot5</a> && src)</td></tr>
+<tr class="memdesc:af000284699d7f5594599f6e742f64e4a inherit pub_methods_classsigc_1_1slot5"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot5.html#af000284699d7f5594599f6e742f64e4a">More...</a><br /></td></tr>
+<tr class="separator:af000284699d7f5594599f6e742f64e4a inherit pub_methods_classsigc_1_1slot5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a> () noexcept</td></tr>
+<tr class="memdesc:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an empty slot. <a href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">More...</a><br /></td></tr>
+<tr class="separator:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">More...</a><br /></td></tr>
+<tr class="separator:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a> (rep_type * rep) noexcept</td></tr>
+<tr class="memdesc:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an existing slot_rep object. <a href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">More...</a><br /></td></tr>
+<tr class="separator:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">More...</a><br /></td></tr>
+<tr class="separator:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a> ()</td></tr>
+<tr class="separator:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the slot is detroyed. <a href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">More...</a><br /></td></tr>
+<tr class="separator:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state. <a href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">More...</a><br /></td></tr>
+<tr class="separator:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">More...</a><br /></td></tr>
+<tr class="separator:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a> ()</td></tr>
+<tr class="memdesc:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Disconnects the slot. <a href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">More...</a><br /></td></tr>
+<tr class="separator:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is invalid. <a href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">More...</a><br /></td></tr>
+<tr class="separator:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a> () const noexcept</td></tr>
+<tr class="memdesc:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Tests whether a slot is null, because the default constructor was used. <a href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">More...</a><br /></td></tr>
+<tr class="separator:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">operator=</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">More...</a><br /></td></tr>
+<tr class="separator:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">operator=</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">More...</a><br /></td></tr>
+<tr class="separator:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694" title="Add a callback that is executed (notified) when the slot is detroyed.">add_destroy_notify_callback()</a>. <a href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">More...</a><br /></td></tr>
+<tr class="separator:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a> (void * parent, void *(* cleanup)(void *)) const noexcept</td></tr>
+<tr class="memdesc:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the parent of this slot. <a href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">More...</a><br /></td></tr>
+<tr class="separator:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state. <a href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">More...</a><br /></td></tr>
+<tr class="separator:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_attribs_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td></tr>
+<tr class="memdesc:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Indicates whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">More...</a><br /></td></tr>
+<tr class="separator:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">rep_type * </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td></tr>
+<tr class="memdesc:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Typed slot_rep object that contains a functor. <a href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">More...</a><br /></td></tr>
+<tr class="separator:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5><br />
+class sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot5.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot5</a> template. </p>
+<p>See the base class for useful methods. This is the template specialization of the unnumbered <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> template for 5 argument(s), specialized for different numbers of arguments This is possible because the template has default (nil) template types.</p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000200">Deprecated:</a></b></dt><dd>Please use the syntax similar to that used by std::function<>: </dd></dl>
+<div class="fragment"><div class="line"><a class="code" href="classsigc_1_1slot.html">sigc::slot</a><void(<span class="keywordtype">bool</span>, <span class="keywordtype">int</span>)> some_slot;</div>
+<div class="ttc" id="aclasssigc_1_1slot_html"><div class="ttname"><a href="classsigc_1_1slot.html">sigc::slot</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::slot# templates.</div><div class="ttdef"><b>Definition:</b> slot.h:1645</div></div>
+</div><!-- fragment --> </div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a013f4139332e23166f7db3be6da4ba91"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a013f4139332e23166f7db3be6da4ba91">◆ </a></span>parent_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="classsigc_1_1slot5.html">slot5</a><T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> <a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a013f4139332e23166f7db3be6da4ba91">parent_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a81c9e625279217aee1ae00696927c39e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a81c9e625279217aee1ae00696927c39e">◆ </a></span>slot() <span class="overload">[1/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a8d5f076fe0207cabd9b2632382bedd89"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8d5f076fe0207cabd9b2632382bedd89">◆ </a></span>slot() <span class="overload">[2/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<div class="memtemplate">
+template <class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot from an arbitrary functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>The desired functor the new slot should be assigned to. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="afab26283085a050db6d75a1bfe273f86"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#afab26283085a050db6d75a1bfe273f86">◆ </a></span>slot() <span class="overload">[3/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, copying an existing one. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="aad4ab45a94e4ec0bddf66c4d88e38b0a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aad4ab45a94e4ec0bddf66c4d88e38b0a">◆ </a></span>slot() <span class="overload">[4/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, moving an existing one. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a3ca127357feda698616f9ed7209653ff"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3ca127357feda698616f9ed7209653ff">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">slot</a>& <a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a copy from another slot. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to make a copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+<a id="a3195ba5b04503a37525bf2142c704f70"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3195ba5b04503a37525bf2142c704f70">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">slot</a>& <a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a move from another slot. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >" name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::slot5 template." alt="" coords="5,259,191,315"/>
+<area shape="rect" id="node2" href="$classsigc_1_1slot5.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="9,155,187,211"/>
+<area shape="rect" id="node3" href="$classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="39,80,157,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="28,5,168,32"/>
+</map>
--- /dev/null
+931cae888e4c01bdfad8cb9cdc502e30
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html">slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot4.html#a4426d0dcf517d0d815d6add3c9490437">arg1_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot4.html#abf1d276525f0120a734b2b054b9cfb3f">arg2_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot4.html#ae1af3fbe3981779b68f5676f46f6085c">arg3_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot4.html#aec7f4747dbe5b581c65c07033ca1bfe5">arg4_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot4.html#a02b0d861a47418b9dbf73ab7db67b0a9">operator()</a>(arg1_type_ _A_a1, arg2_type_ _A_a2, arg3_type_ _A_a3, arg4_type_ _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#aebe6238dace66568d5135f1a7d41e8d1">operator=</a>(const slot & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a0b0b9caae71710771aa3cd90f93755c5">operator=</a>(slot && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot4.html#ac2fb7f8ae312ced5b7436f0a0d062132">sigc::slot4::operator=</a>(const slot4 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot4.html#ad05b8c996262ab1bcac89d8c8004a0b5">sigc::slot4::operator=</a>(slot4 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">sigc::slot_base::operator=</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">sigc::slot_base::operator=</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a704393344c1ba2f6bdda9b466bb81af1">parent_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot4.html#a3f6b5b11385536c1c199ca29468c638a">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a>(void * parent, void *(* cleanup)(void *)) const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#afb4ec5a164ca622ab9c1a97e61e9cfdc">slot</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#aa2691c7a5f59f54788db1b31d4870650">slot</a>(const T_functor & _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#afb9ff761d6f8519ea01b4fd1c254ee60">slot</a>(const slot & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a4e1e1ecd839575d1d928325f8882fbfb">slot</a>(slot && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot4.html#a4b8ef0494eea86c0d787486ce121db91">slot4</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot4.html#a50d331d378ba1f3cb03f39a42a4aa3cf">slot4</a>(const T_functor & _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot4.html#a7b7080168e769cdec8d916f71fa58d21">slot4</a>(const slot4 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot4.html#acf9e9b169fddb40079618f870172f535">slot4</a>(slot4 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a>(rep_type * rep) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html">slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot4.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot4</a> template.
+ <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/slot.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_41a20cc46cbca7c5e1f6e6dab34f9c0b.png" border="0" usemap="#asigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4_inherit__map" id="asigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::slot4 template." alt="" coords="5,259,184,315"/>
+<area shape="rect" href="classsigc_1_1slot4.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="5,155,184,211"/>
+<area shape="rect" href="classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="35,80,154,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="25,5,165,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a704393344c1ba2f6bdda9b466bb81af1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot4.html">slot4</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a704393344c1ba2f6bdda9b466bb81af1">parent_type</a></td></tr>
+<tr class="separator:a704393344c1ba2f6bdda9b466bb81af1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1slot4"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1slot4')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1slot4.html">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td></tr>
+<tr class="memitem:a4426d0dcf517d0d815d6add3c9490437 inherit pub_types_classsigc_1_1slot4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot4.html#a4426d0dcf517d0d815d6add3c9490437">arg1_type_</a></td></tr>
+<tr class="separator:a4426d0dcf517d0d815d6add3c9490437 inherit pub_types_classsigc_1_1slot4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abf1d276525f0120a734b2b054b9cfb3f inherit pub_types_classsigc_1_1slot4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot4.html#abf1d276525f0120a734b2b054b9cfb3f">arg2_type_</a></td></tr>
+<tr class="separator:abf1d276525f0120a734b2b054b9cfb3f inherit pub_types_classsigc_1_1slot4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae1af3fbe3981779b68f5676f46f6085c inherit pub_types_classsigc_1_1slot4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot4.html#ae1af3fbe3981779b68f5676f46f6085c">arg3_type_</a></td></tr>
+<tr class="separator:ae1af3fbe3981779b68f5676f46f6085c inherit pub_types_classsigc_1_1slot4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aec7f4747dbe5b581c65c07033ca1bfe5 inherit pub_types_classsigc_1_1slot4"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot4.html#aec7f4747dbe5b581c65c07033ca1bfe5">arg4_type_</a></td></tr>
+<tr class="separator:aec7f4747dbe5b581c65c07033ca1bfe5 inherit pub_types_classsigc_1_1slot4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3f6b5b11385536c1c199ca29468c638a inherit pub_types_classsigc_1_1slot4"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot4.html#a3f6b5b11385536c1c199ca29468c638a">result_type</a></td></tr>
+<tr class="separator:a3f6b5b11385536c1c199ca29468c638a inherit pub_types_classsigc_1_1slot4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">trackable::func_destroy_notify</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a></td></tr>
+<tr class="separator:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:afb4ec5a164ca622ab9c1a97e61e9cfdc"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#afb4ec5a164ca622ab9c1a97e61e9cfdc">slot</a> ()</td></tr>
+<tr class="separator:afb4ec5a164ca622ab9c1a97e61e9cfdc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afb9ff761d6f8519ea01b4fd1c254ee60"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#afb9ff761d6f8519ea01b4fd1c254ee60">slot</a> (const <a class="el" href="classsigc_1_1slot.html">slot</a> & src)</td></tr>
+<tr class="memdesc:afb9ff761d6f8519ea01b4fd1c254ee60"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#afb9ff761d6f8519ea01b4fd1c254ee60">More...</a><br /></td></tr>
+<tr class="separator:afb9ff761d6f8519ea01b4fd1c254ee60"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa2691c7a5f59f54788db1b31d4870650"><td class="memTemplParams" colspan="2">template<class T_functor > </td></tr>
+<tr class="memitem:aa2691c7a5f59f54788db1b31d4870650"><td class="memTemplItemLeft" align="right" valign="top"> </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#aa2691c7a5f59f54788db1b31d4870650">slot</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:aa2691c7a5f59f54788db1b31d4870650"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an arbitrary functor. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#aa2691c7a5f59f54788db1b31d4870650">More...</a><br /></td></tr>
+<tr class="separator:aa2691c7a5f59f54788db1b31d4870650"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4e1e1ecd839575d1d928325f8882fbfb"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a4e1e1ecd839575d1d928325f8882fbfb">slot</a> (<a class="el" href="classsigc_1_1slot.html">slot</a> && src)</td></tr>
+<tr class="memdesc:a4e1e1ecd839575d1d928325f8882fbfb"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a4e1e1ecd839575d1d928325f8882fbfb">More...</a><br /></td></tr>
+<tr class="separator:a4e1e1ecd839575d1d928325f8882fbfb"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebe6238dace66568d5135f1a7d41e8d1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot.html">slot</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#aebe6238dace66568d5135f1a7d41e8d1">operator=</a> (const <a class="el" href="classsigc_1_1slot.html">slot</a> & src)</td></tr>
+<tr class="memdesc:aebe6238dace66568d5135f1a7d41e8d1"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#aebe6238dace66568d5135f1a7d41e8d1">More...</a><br /></td></tr>
+<tr class="separator:aebe6238dace66568d5135f1a7d41e8d1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0b0b9caae71710771aa3cd90f93755c5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot.html">slot</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a0b0b9caae71710771aa3cd90f93755c5">operator=</a> (<a class="el" href="classsigc_1_1slot.html">slot</a> && src)</td></tr>
+<tr class="memdesc:a0b0b9caae71710771aa3cd90f93755c5"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a0b0b9caae71710771aa3cd90f93755c5">More...</a><br /></td></tr>
+<tr class="separator:a0b0b9caae71710771aa3cd90f93755c5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1slot4"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1slot4')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1slot4.html">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td></tr>
+<tr class="memitem:a4b8ef0494eea86c0d787486ce121db91 inherit pub_methods_classsigc_1_1slot4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot4.html#a4b8ef0494eea86c0d787486ce121db91">slot4</a> ()</td></tr>
+<tr class="separator:a4b8ef0494eea86c0d787486ce121db91 inherit pub_methods_classsigc_1_1slot4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7b7080168e769cdec8d916f71fa58d21 inherit pub_methods_classsigc_1_1slot4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot4.html#a7b7080168e769cdec8d916f71fa58d21">slot4</a> (const <a class="el" href="classsigc_1_1slot4.html">slot4</a> & src)</td></tr>
+<tr class="memdesc:a7b7080168e769cdec8d916f71fa58d21 inherit pub_methods_classsigc_1_1slot4"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot4.html#a7b7080168e769cdec8d916f71fa58d21">More...</a><br /></td></tr>
+<tr class="separator:a7b7080168e769cdec8d916f71fa58d21 inherit pub_methods_classsigc_1_1slot4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50d331d378ba1f3cb03f39a42a4aa3cf inherit pub_methods_classsigc_1_1slot4"><td class="memTemplParams" colspan="2">template<class T_functor > </td></tr>
+<tr class="memitem:a50d331d378ba1f3cb03f39a42a4aa3cf inherit pub_methods_classsigc_1_1slot4"><td class="memTemplItemLeft" align="right" valign="top"> </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot4.html#a50d331d378ba1f3cb03f39a42a4aa3cf">slot4</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:a50d331d378ba1f3cb03f39a42a4aa3cf inherit pub_methods_classsigc_1_1slot4"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an arbitrary functor. <a href="classsigc_1_1slot4.html#a50d331d378ba1f3cb03f39a42a4aa3cf">More...</a><br /></td></tr>
+<tr class="separator:a50d331d378ba1f3cb03f39a42a4aa3cf inherit pub_methods_classsigc_1_1slot4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acf9e9b169fddb40079618f870172f535 inherit pub_methods_classsigc_1_1slot4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot4.html#acf9e9b169fddb40079618f870172f535">slot4</a> (<a class="el" href="classsigc_1_1slot4.html">slot4</a> && src)</td></tr>
+<tr class="memdesc:acf9e9b169fddb40079618f870172f535 inherit pub_methods_classsigc_1_1slot4"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot4.html#acf9e9b169fddb40079618f870172f535">More...</a><br /></td></tr>
+<tr class="separator:acf9e9b169fddb40079618f870172f535 inherit pub_methods_classsigc_1_1slot4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a02b0d861a47418b9dbf73ab7db67b0a9 inherit pub_methods_classsigc_1_1slot4"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot4.html#a02b0d861a47418b9dbf73ab7db67b0a9">operator()</a> (<a class="el" href="classsigc_1_1slot4.html#a4426d0dcf517d0d815d6add3c9490437">arg1_type_</a> _A_a1, <a class="el" href="classsigc_1_1slot4.html#abf1d276525f0120a734b2b054b9cfb3f">arg2_type_</a> _A_a2, <a class="el" href="classsigc_1_1slot4.html#ae1af3fbe3981779b68f5676f46f6085c">arg3_type_</a> _A_a3, <a class="el" href="classsigc_1_1slot4.html#aec7f4747dbe5b581c65c07033ca1bfe5">arg4_type_</a> _A_a4) const</td></tr>
+<tr class="memdesc:a02b0d861a47418b9dbf73ab7db67b0a9 inherit pub_methods_classsigc_1_1slot4"><td class="mdescLeft"> </td><td class="mdescRight">Invoke the contained functor unless slot is in blocking state. <a href="classsigc_1_1slot4.html#a02b0d861a47418b9dbf73ab7db67b0a9">More...</a><br /></td></tr>
+<tr class="separator:a02b0d861a47418b9dbf73ab7db67b0a9 inherit pub_methods_classsigc_1_1slot4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac2fb7f8ae312ced5b7436f0a0d062132 inherit pub_methods_classsigc_1_1slot4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot4.html">slot4</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot4.html#ac2fb7f8ae312ced5b7436f0a0d062132">operator=</a> (const <a class="el" href="classsigc_1_1slot4.html">slot4</a> & src)</td></tr>
+<tr class="memdesc:ac2fb7f8ae312ced5b7436f0a0d062132 inherit pub_methods_classsigc_1_1slot4"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot4.html#ac2fb7f8ae312ced5b7436f0a0d062132">More...</a><br /></td></tr>
+<tr class="separator:ac2fb7f8ae312ced5b7436f0a0d062132 inherit pub_methods_classsigc_1_1slot4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad05b8c996262ab1bcac89d8c8004a0b5 inherit pub_methods_classsigc_1_1slot4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot4.html">slot4</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot4.html#ad05b8c996262ab1bcac89d8c8004a0b5">operator=</a> (<a class="el" href="classsigc_1_1slot4.html">slot4</a> && src)</td></tr>
+<tr class="memdesc:ad05b8c996262ab1bcac89d8c8004a0b5 inherit pub_methods_classsigc_1_1slot4"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot4.html#ad05b8c996262ab1bcac89d8c8004a0b5">More...</a><br /></td></tr>
+<tr class="separator:ad05b8c996262ab1bcac89d8c8004a0b5 inherit pub_methods_classsigc_1_1slot4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a> () noexcept</td></tr>
+<tr class="memdesc:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an empty slot. <a href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">More...</a><br /></td></tr>
+<tr class="separator:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">More...</a><br /></td></tr>
+<tr class="separator:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a> (rep_type * rep) noexcept</td></tr>
+<tr class="memdesc:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an existing slot_rep object. <a href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">More...</a><br /></td></tr>
+<tr class="separator:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">More...</a><br /></td></tr>
+<tr class="separator:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a> ()</td></tr>
+<tr class="separator:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the slot is detroyed. <a href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">More...</a><br /></td></tr>
+<tr class="separator:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state. <a href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">More...</a><br /></td></tr>
+<tr class="separator:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">More...</a><br /></td></tr>
+<tr class="separator:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a> ()</td></tr>
+<tr class="memdesc:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Disconnects the slot. <a href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">More...</a><br /></td></tr>
+<tr class="separator:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is invalid. <a href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">More...</a><br /></td></tr>
+<tr class="separator:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a> () const noexcept</td></tr>
+<tr class="memdesc:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Tests whether a slot is null, because the default constructor was used. <a href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">More...</a><br /></td></tr>
+<tr class="separator:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">operator=</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">More...</a><br /></td></tr>
+<tr class="separator:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">operator=</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">More...</a><br /></td></tr>
+<tr class="separator:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694" title="Add a callback that is executed (notified) when the slot is detroyed.">add_destroy_notify_callback()</a>. <a href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">More...</a><br /></td></tr>
+<tr class="separator:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a> (void * parent, void *(* cleanup)(void *)) const noexcept</td></tr>
+<tr class="memdesc:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the parent of this slot. <a href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">More...</a><br /></td></tr>
+<tr class="separator:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state. <a href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">More...</a><br /></td></tr>
+<tr class="separator:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_attribs_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td></tr>
+<tr class="memdesc:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Indicates whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">More...</a><br /></td></tr>
+<tr class="separator:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">rep_type * </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td></tr>
+<tr class="memdesc:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Typed slot_rep object that contains a functor. <a href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">More...</a><br /></td></tr>
+<tr class="separator:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4><br />
+class sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot4.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot4</a> template. </p>
+<p>See the base class for useful methods. This is the template specialization of the unnumbered <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> template for 4 argument(s), specialized for different numbers of arguments This is possible because the template has default (nil) template types.</p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000199">Deprecated:</a></b></dt><dd>Please use the syntax similar to that used by std::function<>: </dd></dl>
+<div class="fragment"><div class="line"><a class="code" href="classsigc_1_1slot.html">sigc::slot</a><void(<span class="keywordtype">bool</span>, <span class="keywordtype">int</span>)> some_slot;</div>
+<div class="ttc" id="aclasssigc_1_1slot_html"><div class="ttname"><a href="classsigc_1_1slot.html">sigc::slot</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::slot# templates.</div><div class="ttdef"><b>Definition:</b> slot.h:1645</div></div>
+</div><!-- fragment --> </div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a704393344c1ba2f6bdda9b466bb81af1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a704393344c1ba2f6bdda9b466bb81af1">◆ </a></span>parent_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="classsigc_1_1slot4.html">slot4</a><T_return, T_arg1, T_arg2, T_arg3, T_arg4> <a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a704393344c1ba2f6bdda9b466bb81af1">parent_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="afb4ec5a164ca622ab9c1a97e61e9cfdc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#afb4ec5a164ca622ab9c1a97e61e9cfdc">◆ </a></span>slot() <span class="overload">[1/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aa2691c7a5f59f54788db1b31d4870650"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa2691c7a5f59f54788db1b31d4870650">◆ </a></span>slot() <span class="overload">[2/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<div class="memtemplate">
+template <class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot from an arbitrary functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>The desired functor the new slot should be assigned to. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="afb9ff761d6f8519ea01b4fd1c254ee60"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#afb9ff761d6f8519ea01b4fd1c254ee60">◆ </a></span>slot() <span class="overload">[3/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, copying an existing one. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a4e1e1ecd839575d1d928325f8882fbfb"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4e1e1ecd839575d1d928325f8882fbfb">◆ </a></span>slot() <span class="overload">[4/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, moving an existing one. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="aebe6238dace66568d5135f1a7d41e8d1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aebe6238dace66568d5135f1a7d41e8d1">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">slot</a>& <a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a copy from another slot. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to make a copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+<a id="a0b0b9caae71710771aa3cd90f93755c5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0b0b9caae71710771aa3cd90f93755c5">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">slot</a>& <a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a move from another slot. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >" name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::slot4 template." alt="" coords="5,259,184,315"/>
+<area shape="rect" id="node2" href="$classsigc_1_1slot4.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="5,155,184,211"/>
+<area shape="rect" id="node3" href="$classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="35,80,154,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="25,5,165,32"/>
+</map>
--- /dev/null
+24f848511ac2c1b665f0f02a90fac44f
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot3.html#ac6791fffc805aa2303713fea377dbaae">arg1_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot3.html">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot3.html#a7390ac1945e87a1e0d172fe266a58d72">arg2_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot3.html">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot3.html#a54a09bfe0dd9c518ec22cc14a7e43a23">arg3_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot3.html">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot3.html#addbe340b1f547308035707236e690e66">operator()</a>(arg1_type_ _A_a1, arg2_type_ _A_a2, arg3_type_ _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1slot3.html">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a355a28cb253c5a14fb36574316f40e3b">operator=</a>(const slot & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a190287bba2fd66fd0448c586660d1e41">operator=</a>(slot && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot3.html#a2ff8f9202019d25ddab688128c504e72">sigc::slot3::operator=</a>(const slot3 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot3.html">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot3.html#ac40a1cefaf9c356a691dfea6819094b8">sigc::slot3::operator=</a>(slot3 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot3.html">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">sigc::slot_base::operator=</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">sigc::slot_base::operator=</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#adbafac5ab39a4a017406ac9587c9511c">parent_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot3.html#a69cca26f164c63de6ffa70a3806fb936">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot3.html">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a>(void * parent, void *(* cleanup)(void *)) const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ad99678bf6a2affc9a1607046e158b22b">slot</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a492069e82b787edc381f4583bc1ab16d">slot</a>(const T_functor & _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a508b21923e1ef3d7d689984132d89360">slot</a>(const slot & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a0e8a890566381060e52ffbd74cc4cca4">slot</a>(slot && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot3.html#ac477d74beed45b2b3e26d19b083147ad">slot3</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot3.html">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot3.html#aeb40907cf0589e97fd541c71e368ad03">slot3</a>(const T_functor & _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1slot3.html">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot3.html#afa87acf0475e178f8d970bf05f84b04b">slot3</a>(const slot3 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot3.html">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot3.html#a74644090c829923a4dda5e09f932d4f9">slot3</a>(slot3 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot3.html">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a>(rep_type * rep) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot3.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot3</a> template.
+ <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/slot.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4__inherit__graph.png" border="0" usemap="#asigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map" id="asigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::slot3 template." alt="" coords="11,244,189,300"/>
+<area shape="rect" href="classsigc_1_1slot3.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="5,155,195,196"/>
+<area shape="rect" href="classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="41,80,159,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="30,5,170,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:adbafac5ab39a4a017406ac9587c9511c"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot3.html">slot3</a>< T_return, T_arg1, T_arg2, T_arg3 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#adbafac5ab39a4a017406ac9587c9511c">parent_type</a></td></tr>
+<tr class="separator:adbafac5ab39a4a017406ac9587c9511c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1slot3"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1slot3')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1slot3.html">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a></td></tr>
+<tr class="memitem:ac6791fffc805aa2303713fea377dbaae inherit pub_types_classsigc_1_1slot3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot3.html#ac6791fffc805aa2303713fea377dbaae">arg1_type_</a></td></tr>
+<tr class="separator:ac6791fffc805aa2303713fea377dbaae inherit pub_types_classsigc_1_1slot3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7390ac1945e87a1e0d172fe266a58d72 inherit pub_types_classsigc_1_1slot3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot3.html#a7390ac1945e87a1e0d172fe266a58d72">arg2_type_</a></td></tr>
+<tr class="separator:a7390ac1945e87a1e0d172fe266a58d72 inherit pub_types_classsigc_1_1slot3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a54a09bfe0dd9c518ec22cc14a7e43a23 inherit pub_types_classsigc_1_1slot3"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot3.html#a54a09bfe0dd9c518ec22cc14a7e43a23">arg3_type_</a></td></tr>
+<tr class="separator:a54a09bfe0dd9c518ec22cc14a7e43a23 inherit pub_types_classsigc_1_1slot3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a69cca26f164c63de6ffa70a3806fb936 inherit pub_types_classsigc_1_1slot3"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot3.html#a69cca26f164c63de6ffa70a3806fb936">result_type</a></td></tr>
+<tr class="separator:a69cca26f164c63de6ffa70a3806fb936 inherit pub_types_classsigc_1_1slot3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">trackable::func_destroy_notify</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a></td></tr>
+<tr class="separator:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:ad99678bf6a2affc9a1607046e158b22b"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ad99678bf6a2affc9a1607046e158b22b">slot</a> ()</td></tr>
+<tr class="separator:ad99678bf6a2affc9a1607046e158b22b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a508b21923e1ef3d7d689984132d89360"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a508b21923e1ef3d7d689984132d89360">slot</a> (const <a class="el" href="classsigc_1_1slot.html">slot</a> & src)</td></tr>
+<tr class="memdesc:a508b21923e1ef3d7d689984132d89360"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a508b21923e1ef3d7d689984132d89360">More...</a><br /></td></tr>
+<tr class="separator:a508b21923e1ef3d7d689984132d89360"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a492069e82b787edc381f4583bc1ab16d"><td class="memTemplParams" colspan="2">template<class T_functor > </td></tr>
+<tr class="memitem:a492069e82b787edc381f4583bc1ab16d"><td class="memTemplItemLeft" align="right" valign="top"> </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a492069e82b787edc381f4583bc1ab16d">slot</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:a492069e82b787edc381f4583bc1ab16d"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an arbitrary functor. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a492069e82b787edc381f4583bc1ab16d">More...</a><br /></td></tr>
+<tr class="separator:a492069e82b787edc381f4583bc1ab16d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0e8a890566381060e52ffbd74cc4cca4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a0e8a890566381060e52ffbd74cc4cca4">slot</a> (<a class="el" href="classsigc_1_1slot.html">slot</a> && src)</td></tr>
+<tr class="memdesc:a0e8a890566381060e52ffbd74cc4cca4"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a0e8a890566381060e52ffbd74cc4cca4">More...</a><br /></td></tr>
+<tr class="separator:a0e8a890566381060e52ffbd74cc4cca4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a355a28cb253c5a14fb36574316f40e3b"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot.html">slot</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a355a28cb253c5a14fb36574316f40e3b">operator=</a> (const <a class="el" href="classsigc_1_1slot.html">slot</a> & src)</td></tr>
+<tr class="memdesc:a355a28cb253c5a14fb36574316f40e3b"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a355a28cb253c5a14fb36574316f40e3b">More...</a><br /></td></tr>
+<tr class="separator:a355a28cb253c5a14fb36574316f40e3b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a190287bba2fd66fd0448c586660d1e41"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot.html">slot</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a190287bba2fd66fd0448c586660d1e41">operator=</a> (<a class="el" href="classsigc_1_1slot.html">slot</a> && src)</td></tr>
+<tr class="memdesc:a190287bba2fd66fd0448c586660d1e41"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a190287bba2fd66fd0448c586660d1e41">More...</a><br /></td></tr>
+<tr class="separator:a190287bba2fd66fd0448c586660d1e41"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1slot3"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1slot3')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1slot3.html">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a></td></tr>
+<tr class="memitem:ac477d74beed45b2b3e26d19b083147ad inherit pub_methods_classsigc_1_1slot3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot3.html#ac477d74beed45b2b3e26d19b083147ad">slot3</a> ()</td></tr>
+<tr class="separator:ac477d74beed45b2b3e26d19b083147ad inherit pub_methods_classsigc_1_1slot3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa87acf0475e178f8d970bf05f84b04b inherit pub_methods_classsigc_1_1slot3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot3.html#afa87acf0475e178f8d970bf05f84b04b">slot3</a> (const <a class="el" href="classsigc_1_1slot3.html">slot3</a> & src)</td></tr>
+<tr class="memdesc:afa87acf0475e178f8d970bf05f84b04b inherit pub_methods_classsigc_1_1slot3"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot3.html#afa87acf0475e178f8d970bf05f84b04b">More...</a><br /></td></tr>
+<tr class="separator:afa87acf0475e178f8d970bf05f84b04b inherit pub_methods_classsigc_1_1slot3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aeb40907cf0589e97fd541c71e368ad03 inherit pub_methods_classsigc_1_1slot3"><td class="memTemplParams" colspan="2">template<class T_functor > </td></tr>
+<tr class="memitem:aeb40907cf0589e97fd541c71e368ad03 inherit pub_methods_classsigc_1_1slot3"><td class="memTemplItemLeft" align="right" valign="top"> </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot3.html#aeb40907cf0589e97fd541c71e368ad03">slot3</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:aeb40907cf0589e97fd541c71e368ad03 inherit pub_methods_classsigc_1_1slot3"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an arbitrary functor. <a href="classsigc_1_1slot3.html#aeb40907cf0589e97fd541c71e368ad03">More...</a><br /></td></tr>
+<tr class="separator:aeb40907cf0589e97fd541c71e368ad03 inherit pub_methods_classsigc_1_1slot3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a74644090c829923a4dda5e09f932d4f9 inherit pub_methods_classsigc_1_1slot3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot3.html#a74644090c829923a4dda5e09f932d4f9">slot3</a> (<a class="el" href="classsigc_1_1slot3.html">slot3</a> && src)</td></tr>
+<tr class="memdesc:a74644090c829923a4dda5e09f932d4f9 inherit pub_methods_classsigc_1_1slot3"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot3.html#a74644090c829923a4dda5e09f932d4f9">More...</a><br /></td></tr>
+<tr class="separator:a74644090c829923a4dda5e09f932d4f9 inherit pub_methods_classsigc_1_1slot3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:addbe340b1f547308035707236e690e66 inherit pub_methods_classsigc_1_1slot3"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot3.html#addbe340b1f547308035707236e690e66">operator()</a> (<a class="el" href="classsigc_1_1slot3.html#ac6791fffc805aa2303713fea377dbaae">arg1_type_</a> _A_a1, <a class="el" href="classsigc_1_1slot3.html#a7390ac1945e87a1e0d172fe266a58d72">arg2_type_</a> _A_a2, <a class="el" href="classsigc_1_1slot3.html#a54a09bfe0dd9c518ec22cc14a7e43a23">arg3_type_</a> _A_a3) const</td></tr>
+<tr class="memdesc:addbe340b1f547308035707236e690e66 inherit pub_methods_classsigc_1_1slot3"><td class="mdescLeft"> </td><td class="mdescRight">Invoke the contained functor unless slot is in blocking state. <a href="classsigc_1_1slot3.html#addbe340b1f547308035707236e690e66">More...</a><br /></td></tr>
+<tr class="separator:addbe340b1f547308035707236e690e66 inherit pub_methods_classsigc_1_1slot3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2ff8f9202019d25ddab688128c504e72 inherit pub_methods_classsigc_1_1slot3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot3.html">slot3</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot3.html#a2ff8f9202019d25ddab688128c504e72">operator=</a> (const <a class="el" href="classsigc_1_1slot3.html">slot3</a> & src)</td></tr>
+<tr class="memdesc:a2ff8f9202019d25ddab688128c504e72 inherit pub_methods_classsigc_1_1slot3"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot3.html#a2ff8f9202019d25ddab688128c504e72">More...</a><br /></td></tr>
+<tr class="separator:a2ff8f9202019d25ddab688128c504e72 inherit pub_methods_classsigc_1_1slot3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac40a1cefaf9c356a691dfea6819094b8 inherit pub_methods_classsigc_1_1slot3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot3.html">slot3</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot3.html#ac40a1cefaf9c356a691dfea6819094b8">operator=</a> (<a class="el" href="classsigc_1_1slot3.html">slot3</a> && src)</td></tr>
+<tr class="memdesc:ac40a1cefaf9c356a691dfea6819094b8 inherit pub_methods_classsigc_1_1slot3"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot3.html#ac40a1cefaf9c356a691dfea6819094b8">More...</a><br /></td></tr>
+<tr class="separator:ac40a1cefaf9c356a691dfea6819094b8 inherit pub_methods_classsigc_1_1slot3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a> () noexcept</td></tr>
+<tr class="memdesc:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an empty slot. <a href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">More...</a><br /></td></tr>
+<tr class="separator:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">More...</a><br /></td></tr>
+<tr class="separator:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a> (rep_type * rep) noexcept</td></tr>
+<tr class="memdesc:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an existing slot_rep object. <a href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">More...</a><br /></td></tr>
+<tr class="separator:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">More...</a><br /></td></tr>
+<tr class="separator:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a> ()</td></tr>
+<tr class="separator:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the slot is detroyed. <a href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">More...</a><br /></td></tr>
+<tr class="separator:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state. <a href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">More...</a><br /></td></tr>
+<tr class="separator:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">More...</a><br /></td></tr>
+<tr class="separator:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a> ()</td></tr>
+<tr class="memdesc:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Disconnects the slot. <a href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">More...</a><br /></td></tr>
+<tr class="separator:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is invalid. <a href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">More...</a><br /></td></tr>
+<tr class="separator:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a> () const noexcept</td></tr>
+<tr class="memdesc:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Tests whether a slot is null, because the default constructor was used. <a href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">More...</a><br /></td></tr>
+<tr class="separator:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">operator=</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">More...</a><br /></td></tr>
+<tr class="separator:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">operator=</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">More...</a><br /></td></tr>
+<tr class="separator:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694" title="Add a callback that is executed (notified) when the slot is detroyed.">add_destroy_notify_callback()</a>. <a href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">More...</a><br /></td></tr>
+<tr class="separator:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a> (void * parent, void *(* cleanup)(void *)) const noexcept</td></tr>
+<tr class="memdesc:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the parent of this slot. <a href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">More...</a><br /></td></tr>
+<tr class="separator:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state. <a href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">More...</a><br /></td></tr>
+<tr class="separator:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_attribs_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td></tr>
+<tr class="memdesc:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Indicates whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">More...</a><br /></td></tr>
+<tr class="separator:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">rep_type * </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td></tr>
+<tr class="memdesc:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Typed slot_rep object that contains a functor. <a href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">More...</a><br /></td></tr>
+<tr class="separator:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2, class T_arg3><br />
+class sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot3.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot3</a> template. </p>
+<p>See the base class for useful methods. This is the template specialization of the unnumbered <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> template for 3 argument(s), specialized for different numbers of arguments This is possible because the template has default (nil) template types.</p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000198">Deprecated:</a></b></dt><dd>Please use the syntax similar to that used by std::function<>: </dd></dl>
+<div class="fragment"><div class="line"><a class="code" href="classsigc_1_1slot.html">sigc::slot</a><void(<span class="keywordtype">bool</span>, <span class="keywordtype">int</span>)> some_slot;</div>
+<div class="ttc" id="aclasssigc_1_1slot_html"><div class="ttname"><a href="classsigc_1_1slot.html">sigc::slot</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::slot# templates.</div><div class="ttdef"><b>Definition:</b> slot.h:1645</div></div>
+</div><!-- fragment --> </div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="adbafac5ab39a4a017406ac9587c9511c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#adbafac5ab39a4a017406ac9587c9511c">◆ </a></span>parent_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="classsigc_1_1slot3.html">slot3</a><T_return, T_arg1, T_arg2, T_arg3> <a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#adbafac5ab39a4a017406ac9587c9511c">parent_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="ad99678bf6a2affc9a1607046e158b22b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad99678bf6a2affc9a1607046e158b22b">◆ </a></span>slot() <span class="overload">[1/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a492069e82b787edc381f4583bc1ab16d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a492069e82b787edc381f4583bc1ab16d">◆ </a></span>slot() <span class="overload">[2/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<div class="memtemplate">
+template <class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot from an arbitrary functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>The desired functor the new slot should be assigned to. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a508b21923e1ef3d7d689984132d89360"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a508b21923e1ef3d7d689984132d89360">◆ </a></span>slot() <span class="overload">[3/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, T_arg3, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, copying an existing one. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a0e8a890566381060e52ffbd74cc4cca4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0e8a890566381060e52ffbd74cc4cca4">◆ </a></span>slot() <span class="overload">[4/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, T_arg3, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, moving an existing one. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a355a28cb253c5a14fb36574316f40e3b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a355a28cb253c5a14fb36574316f40e3b">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">slot</a>& <a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, T_arg3, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a copy from another slot. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to make a copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+<a id="a190287bba2fd66fd0448c586660d1e41"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a190287bba2fd66fd0448c586660d1e41">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">slot</a>& <a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, T_arg3, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, T_arg3, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a move from another slot. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >" name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::slot3 template." alt="" coords="11,244,189,300"/>
+<area shape="rect" id="node2" href="$classsigc_1_1slot3.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="5,155,195,196"/>
+<area shape="rect" id="node3" href="$classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="41,80,159,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="30,5,170,32"/>
+</map>
--- /dev/null
+189f87a0a34bed2cb2c913ea87b1f36a
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot2.html#ae69b03a4119d61a0a521b0ad5ddaae46">arg1_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot2.html">sigc::slot2< T_return, T_arg1, T_arg2 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot2.html#af03b1377bbfcdc742a7c00f4c2c419f7">arg2_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot2.html">sigc::slot2< T_return, T_arg1, T_arg2 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot2.html#aa2abda2a910db19bbb7a2a08d867e358">operator()</a>(arg1_type_ _A_a1, arg2_type_ _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1slot2.html">sigc::slot2< T_return, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#aa2298b81729a3f9879283a99ac31dfaf">operator=</a>(const slot & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a98c52bf9ca78dc5f940ec5f5ca466bd9">operator=</a>(slot && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot2.html#a6b3d5de4d2e7a6134cc883b98380caa7">sigc::slot2::operator=</a>(const slot2 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot2.html">sigc::slot2< T_return, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot2.html#aeda5a84c674376aa0800a0bf876bb5fa">sigc::slot2::operator=</a>(slot2 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot2.html">sigc::slot2< T_return, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">sigc::slot_base::operator=</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">sigc::slot_base::operator=</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a867e776b644ca32a703866a424ae3ba5">parent_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot2.html#a0bb920e3d5628c3d01a4337a2a8a97fc">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot2.html">sigc::slot2< T_return, T_arg1, T_arg2 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a>(void * parent, void *(* cleanup)(void *)) const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#aae3ba9ffc1ab8ea95ba75dd6f5753c48">slot</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a32b5350736a34c13c5e64d3ef6f5ba84">slot</a>(const T_functor & _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a7b7a49a2270daf31abdc237d440b21b1">slot</a>(const slot & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ad034a7e1a5344031ee9764c063054814">slot</a>(slot && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot2.html#a3f9f6cf199bbb40011eca25eb9da67c2">slot2</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot2.html">sigc::slot2< T_return, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot2.html#a14641110a8fdbb060a58c037b9000730">slot2</a>(const T_functor & _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1slot2.html">sigc::slot2< T_return, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot2.html#a868deef9d947dfa4fcbb0cfe64cbd42e">slot2</a>(const slot2 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot2.html">sigc::slot2< T_return, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot2.html#a4719ba9494f87e682b6a6d04b02413e7">slot2</a>(slot2 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot2.html">sigc::slot2< T_return, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a>(rep_type * rep) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot2.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot2</a> template.
+ <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/slot.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4__inherit__graph.png" border="0" usemap="#asigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map" id="asigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::slot2 template." alt="" coords="9,244,163,300"/>
+<area shape="rect" href="classsigc_1_1slot2.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="5,155,167,196"/>
+<area shape="rect" href="classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="27,80,145,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="16,5,156,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a867e776b644ca32a703866a424ae3ba5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot2.html">slot2</a>< T_return, T_arg1, T_arg2 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a867e776b644ca32a703866a424ae3ba5">parent_type</a></td></tr>
+<tr class="separator:a867e776b644ca32a703866a424ae3ba5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1slot2"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1slot2')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1slot2.html">sigc::slot2< T_return, T_arg1, T_arg2 ></a></td></tr>
+<tr class="memitem:ae69b03a4119d61a0a521b0ad5ddaae46 inherit pub_types_classsigc_1_1slot2"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot2.html#ae69b03a4119d61a0a521b0ad5ddaae46">arg1_type_</a></td></tr>
+<tr class="separator:ae69b03a4119d61a0a521b0ad5ddaae46 inherit pub_types_classsigc_1_1slot2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af03b1377bbfcdc742a7c00f4c2c419f7 inherit pub_types_classsigc_1_1slot2"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot2.html#af03b1377bbfcdc742a7c00f4c2c419f7">arg2_type_</a></td></tr>
+<tr class="separator:af03b1377bbfcdc742a7c00f4c2c419f7 inherit pub_types_classsigc_1_1slot2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0bb920e3d5628c3d01a4337a2a8a97fc inherit pub_types_classsigc_1_1slot2"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot2.html#a0bb920e3d5628c3d01a4337a2a8a97fc">result_type</a></td></tr>
+<tr class="separator:a0bb920e3d5628c3d01a4337a2a8a97fc inherit pub_types_classsigc_1_1slot2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">trackable::func_destroy_notify</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a></td></tr>
+<tr class="separator:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:aae3ba9ffc1ab8ea95ba75dd6f5753c48"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#aae3ba9ffc1ab8ea95ba75dd6f5753c48">slot</a> ()</td></tr>
+<tr class="separator:aae3ba9ffc1ab8ea95ba75dd6f5753c48"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7b7a49a2270daf31abdc237d440b21b1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a7b7a49a2270daf31abdc237d440b21b1">slot</a> (const <a class="el" href="classsigc_1_1slot.html">slot</a> & src)</td></tr>
+<tr class="memdesc:a7b7a49a2270daf31abdc237d440b21b1"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a7b7a49a2270daf31abdc237d440b21b1">More...</a><br /></td></tr>
+<tr class="separator:a7b7a49a2270daf31abdc237d440b21b1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a32b5350736a34c13c5e64d3ef6f5ba84"><td class="memTemplParams" colspan="2">template<class T_functor > </td></tr>
+<tr class="memitem:a32b5350736a34c13c5e64d3ef6f5ba84"><td class="memTemplItemLeft" align="right" valign="top"> </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a32b5350736a34c13c5e64d3ef6f5ba84">slot</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:a32b5350736a34c13c5e64d3ef6f5ba84"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an arbitrary functor. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a32b5350736a34c13c5e64d3ef6f5ba84">More...</a><br /></td></tr>
+<tr class="separator:a32b5350736a34c13c5e64d3ef6f5ba84"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad034a7e1a5344031ee9764c063054814"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ad034a7e1a5344031ee9764c063054814">slot</a> (<a class="el" href="classsigc_1_1slot.html">slot</a> && src)</td></tr>
+<tr class="memdesc:ad034a7e1a5344031ee9764c063054814"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ad034a7e1a5344031ee9764c063054814">More...</a><br /></td></tr>
+<tr class="separator:ad034a7e1a5344031ee9764c063054814"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa2298b81729a3f9879283a99ac31dfaf"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot.html">slot</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#aa2298b81729a3f9879283a99ac31dfaf">operator=</a> (const <a class="el" href="classsigc_1_1slot.html">slot</a> & src)</td></tr>
+<tr class="memdesc:aa2298b81729a3f9879283a99ac31dfaf"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#aa2298b81729a3f9879283a99ac31dfaf">More...</a><br /></td></tr>
+<tr class="separator:aa2298b81729a3f9879283a99ac31dfaf"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a98c52bf9ca78dc5f940ec5f5ca466bd9"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot.html">slot</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a98c52bf9ca78dc5f940ec5f5ca466bd9">operator=</a> (<a class="el" href="classsigc_1_1slot.html">slot</a> && src)</td></tr>
+<tr class="memdesc:a98c52bf9ca78dc5f940ec5f5ca466bd9"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a98c52bf9ca78dc5f940ec5f5ca466bd9">More...</a><br /></td></tr>
+<tr class="separator:a98c52bf9ca78dc5f940ec5f5ca466bd9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1slot2"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1slot2')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1slot2.html">sigc::slot2< T_return, T_arg1, T_arg2 ></a></td></tr>
+<tr class="memitem:a3f9f6cf199bbb40011eca25eb9da67c2 inherit pub_methods_classsigc_1_1slot2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot2.html#a3f9f6cf199bbb40011eca25eb9da67c2">slot2</a> ()</td></tr>
+<tr class="separator:a3f9f6cf199bbb40011eca25eb9da67c2 inherit pub_methods_classsigc_1_1slot2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a868deef9d947dfa4fcbb0cfe64cbd42e inherit pub_methods_classsigc_1_1slot2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot2.html#a868deef9d947dfa4fcbb0cfe64cbd42e">slot2</a> (const <a class="el" href="classsigc_1_1slot2.html">slot2</a> & src)</td></tr>
+<tr class="memdesc:a868deef9d947dfa4fcbb0cfe64cbd42e inherit pub_methods_classsigc_1_1slot2"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot2.html#a868deef9d947dfa4fcbb0cfe64cbd42e">More...</a><br /></td></tr>
+<tr class="separator:a868deef9d947dfa4fcbb0cfe64cbd42e inherit pub_methods_classsigc_1_1slot2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a14641110a8fdbb060a58c037b9000730 inherit pub_methods_classsigc_1_1slot2"><td class="memTemplParams" colspan="2">template<class T_functor > </td></tr>
+<tr class="memitem:a14641110a8fdbb060a58c037b9000730 inherit pub_methods_classsigc_1_1slot2"><td class="memTemplItemLeft" align="right" valign="top"> </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot2.html#a14641110a8fdbb060a58c037b9000730">slot2</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:a14641110a8fdbb060a58c037b9000730 inherit pub_methods_classsigc_1_1slot2"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an arbitrary functor. <a href="classsigc_1_1slot2.html#a14641110a8fdbb060a58c037b9000730">More...</a><br /></td></tr>
+<tr class="separator:a14641110a8fdbb060a58c037b9000730 inherit pub_methods_classsigc_1_1slot2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4719ba9494f87e682b6a6d04b02413e7 inherit pub_methods_classsigc_1_1slot2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot2.html#a4719ba9494f87e682b6a6d04b02413e7">slot2</a> (<a class="el" href="classsigc_1_1slot2.html">slot2</a> && src)</td></tr>
+<tr class="memdesc:a4719ba9494f87e682b6a6d04b02413e7 inherit pub_methods_classsigc_1_1slot2"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot2.html#a4719ba9494f87e682b6a6d04b02413e7">More...</a><br /></td></tr>
+<tr class="separator:a4719ba9494f87e682b6a6d04b02413e7 inherit pub_methods_classsigc_1_1slot2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa2abda2a910db19bbb7a2a08d867e358 inherit pub_methods_classsigc_1_1slot2"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot2.html#aa2abda2a910db19bbb7a2a08d867e358">operator()</a> (<a class="el" href="classsigc_1_1slot2.html#ae69b03a4119d61a0a521b0ad5ddaae46">arg1_type_</a> _A_a1, <a class="el" href="classsigc_1_1slot2.html#af03b1377bbfcdc742a7c00f4c2c419f7">arg2_type_</a> _A_a2) const</td></tr>
+<tr class="memdesc:aa2abda2a910db19bbb7a2a08d867e358 inherit pub_methods_classsigc_1_1slot2"><td class="mdescLeft"> </td><td class="mdescRight">Invoke the contained functor unless slot is in blocking state. <a href="classsigc_1_1slot2.html#aa2abda2a910db19bbb7a2a08d867e358">More...</a><br /></td></tr>
+<tr class="separator:aa2abda2a910db19bbb7a2a08d867e358 inherit pub_methods_classsigc_1_1slot2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a6b3d5de4d2e7a6134cc883b98380caa7 inherit pub_methods_classsigc_1_1slot2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot2.html">slot2</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot2.html#a6b3d5de4d2e7a6134cc883b98380caa7">operator=</a> (const <a class="el" href="classsigc_1_1slot2.html">slot2</a> & src)</td></tr>
+<tr class="memdesc:a6b3d5de4d2e7a6134cc883b98380caa7 inherit pub_methods_classsigc_1_1slot2"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot2.html#a6b3d5de4d2e7a6134cc883b98380caa7">More...</a><br /></td></tr>
+<tr class="separator:a6b3d5de4d2e7a6134cc883b98380caa7 inherit pub_methods_classsigc_1_1slot2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aeda5a84c674376aa0800a0bf876bb5fa inherit pub_methods_classsigc_1_1slot2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot2.html">slot2</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot2.html#aeda5a84c674376aa0800a0bf876bb5fa">operator=</a> (<a class="el" href="classsigc_1_1slot2.html">slot2</a> && src)</td></tr>
+<tr class="memdesc:aeda5a84c674376aa0800a0bf876bb5fa inherit pub_methods_classsigc_1_1slot2"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot2.html#aeda5a84c674376aa0800a0bf876bb5fa">More...</a><br /></td></tr>
+<tr class="separator:aeda5a84c674376aa0800a0bf876bb5fa inherit pub_methods_classsigc_1_1slot2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a> () noexcept</td></tr>
+<tr class="memdesc:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an empty slot. <a href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">More...</a><br /></td></tr>
+<tr class="separator:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">More...</a><br /></td></tr>
+<tr class="separator:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a> (rep_type * rep) noexcept</td></tr>
+<tr class="memdesc:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an existing slot_rep object. <a href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">More...</a><br /></td></tr>
+<tr class="separator:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">More...</a><br /></td></tr>
+<tr class="separator:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a> ()</td></tr>
+<tr class="separator:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the slot is detroyed. <a href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">More...</a><br /></td></tr>
+<tr class="separator:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state. <a href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">More...</a><br /></td></tr>
+<tr class="separator:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">More...</a><br /></td></tr>
+<tr class="separator:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a> ()</td></tr>
+<tr class="memdesc:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Disconnects the slot. <a href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">More...</a><br /></td></tr>
+<tr class="separator:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is invalid. <a href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">More...</a><br /></td></tr>
+<tr class="separator:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a> () const noexcept</td></tr>
+<tr class="memdesc:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Tests whether a slot is null, because the default constructor was used. <a href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">More...</a><br /></td></tr>
+<tr class="separator:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">operator=</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">More...</a><br /></td></tr>
+<tr class="separator:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">operator=</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">More...</a><br /></td></tr>
+<tr class="separator:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694" title="Add a callback that is executed (notified) when the slot is detroyed.">add_destroy_notify_callback()</a>. <a href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">More...</a><br /></td></tr>
+<tr class="separator:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a> (void * parent, void *(* cleanup)(void *)) const noexcept</td></tr>
+<tr class="memdesc:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the parent of this slot. <a href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">More...</a><br /></td></tr>
+<tr class="separator:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state. <a href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">More...</a><br /></td></tr>
+<tr class="separator:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_attribs_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td></tr>
+<tr class="memdesc:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Indicates whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">More...</a><br /></td></tr>
+<tr class="separator:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">rep_type * </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td></tr>
+<tr class="memdesc:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Typed slot_rep object that contains a functor. <a href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">More...</a><br /></td></tr>
+<tr class="separator:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1, class T_arg2><br />
+class sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot2.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot2</a> template. </p>
+<p>See the base class for useful methods. This is the template specialization of the unnumbered <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> template for 2 argument(s), specialized for different numbers of arguments This is possible because the template has default (nil) template types.</p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000197">Deprecated:</a></b></dt><dd>Please use the syntax similar to that used by std::function<>: </dd></dl>
+<div class="fragment"><div class="line"><a class="code" href="classsigc_1_1slot.html">sigc::slot</a><void(<span class="keywordtype">bool</span>, <span class="keywordtype">int</span>)> some_slot;</div>
+<div class="ttc" id="aclasssigc_1_1slot_html"><div class="ttname"><a href="classsigc_1_1slot.html">sigc::slot</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::slot# templates.</div><div class="ttdef"><b>Definition:</b> slot.h:1645</div></div>
+</div><!-- fragment --> </div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a867e776b644ca32a703866a424ae3ba5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a867e776b644ca32a703866a424ae3ba5">◆ </a></span>parent_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="classsigc_1_1slot2.html">slot2</a><T_return, T_arg1, T_arg2> <a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a867e776b644ca32a703866a424ae3ba5">parent_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="aae3ba9ffc1ab8ea95ba75dd6f5753c48"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aae3ba9ffc1ab8ea95ba75dd6f5753c48">◆ </a></span>slot() <span class="overload">[1/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a32b5350736a34c13c5e64d3ef6f5ba84"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a32b5350736a34c13c5e64d3ef6f5ba84">◆ </a></span>slot() <span class="overload">[2/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+<div class="memtemplate">
+template <class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot from an arbitrary functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>The desired functor the new slot should be assigned to. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a7b7a49a2270daf31abdc237d440b21b1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7b7a49a2270daf31abdc237d440b21b1">◆ </a></span>slot() <span class="overload">[3/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, copying an existing one. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="ad034a7e1a5344031ee9764c063054814"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad034a7e1a5344031ee9764c063054814">◆ </a></span>slot() <span class="overload">[4/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, moving an existing one. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="aa2298b81729a3f9879283a99ac31dfaf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa2298b81729a3f9879283a99ac31dfaf">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">slot</a>& <a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a copy from another slot. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to make a copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+<a id="a98c52bf9ca78dc5f940ec5f5ca466bd9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a98c52bf9ca78dc5f940ec5f5ca466bd9">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">slot</a>& <a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, T_arg2, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a move from another slot. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >" name="sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::slot2 template." alt="" coords="9,244,163,300"/>
+<area shape="rect" id="node2" href="$classsigc_1_1slot2.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="5,155,167,196"/>
+<area shape="rect" id="node3" href="$classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="27,80,145,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="16,5,156,32"/>
+</map>
--- /dev/null
+6c577f331a668c624420fca606d56fd1
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot1.html#a4d81838957a9ccc6cb4c104706a37a89">arg1_type_</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot1.html">sigc::slot1< T_return, T_arg1 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot1.html#ae9082daf31fdbb57da71e8c38a9ae1ab">operator()</a>(arg1_type_ _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1slot1.html">sigc::slot1< T_return, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a50efa6d5ba0613851a7aac56b98f7eb8">operator=</a>(const slot & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a88a00e43c5ed084441655b2f9e32c621">operator=</a>(slot && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot1.html#a2e0d65cfc434718b6c5f7d7135ac384e">sigc::slot1::operator=</a>(const slot1 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot1.html">sigc::slot1< T_return, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot1.html#a195acd57b42149a2faaeec4c6725825a">sigc::slot1::operator=</a>(slot1 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot1.html">sigc::slot1< T_return, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">sigc::slot_base::operator=</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">sigc::slot_base::operator=</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a2b6b5b8590577c765c7a32f7e619250a">parent_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot1.html#ab4991fe5d80761ddab482fda9ebe6d17">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot1.html">sigc::slot1< T_return, T_arg1 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a>(void * parent, void *(* cleanup)(void *)) const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ad34e10be904557368c241f53e972c8e7">slot</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a5d486e3227ed5f73b791c4e202a168b4">slot</a>(const T_functor & _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a2765416a5563c2d264c892aa6ab5a83c">slot</a>(const slot & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ad22e5b50e474d072bb17489e9342c478">slot</a>(slot && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot1.html#aa8ac5eadba778c11a424e255889e67f6">slot1</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot1.html">sigc::slot1< T_return, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot1.html#a20999708c6db16a3015beca7d4ad866e">slot1</a>(const T_functor & _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1slot1.html">sigc::slot1< T_return, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot1.html#ac6ecaff0a20a57d2168ea126e565e36a">slot1</a>(const slot1 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot1.html">sigc::slot1< T_return, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot1.html#a4ab8f18f97f843558f11adb9d1e8e478">slot1</a>(slot1 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot1.html">sigc::slot1< T_return, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a>(rep_type * rep) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot1.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot1</a> template.
+ <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/slot.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4__inherit__graph.png" border="0" usemap="#asigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map" id="asigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::slot1 template." alt="" coords="9,244,163,300"/>
+<area shape="rect" href="classsigc_1_1slot1.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="5,155,167,196"/>
+<area shape="rect" href="classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="27,80,145,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="16,5,156,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a2b6b5b8590577c765c7a32f7e619250a"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot1.html">slot1</a>< T_return, T_arg1 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a2b6b5b8590577c765c7a32f7e619250a">parent_type</a></td></tr>
+<tr class="separator:a2b6b5b8590577c765c7a32f7e619250a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1slot1"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1slot1')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1slot1.html">sigc::slot1< T_return, T_arg1 ></a></td></tr>
+<tr class="memitem:a4d81838957a9ccc6cb4c104706a37a89 inherit pub_types_classsigc_1_1slot1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot1.html#a4d81838957a9ccc6cb4c104706a37a89">arg1_type_</a></td></tr>
+<tr class="separator:a4d81838957a9ccc6cb4c104706a37a89 inherit pub_types_classsigc_1_1slot1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab4991fe5d80761ddab482fda9ebe6d17 inherit pub_types_classsigc_1_1slot1"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot1.html#ab4991fe5d80761ddab482fda9ebe6d17">result_type</a></td></tr>
+<tr class="separator:ab4991fe5d80761ddab482fda9ebe6d17 inherit pub_types_classsigc_1_1slot1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">trackable::func_destroy_notify</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a></td></tr>
+<tr class="separator:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:ad34e10be904557368c241f53e972c8e7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ad34e10be904557368c241f53e972c8e7">slot</a> ()</td></tr>
+<tr class="separator:ad34e10be904557368c241f53e972c8e7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2765416a5563c2d264c892aa6ab5a83c"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a2765416a5563c2d264c892aa6ab5a83c">slot</a> (const <a class="el" href="classsigc_1_1slot.html">slot</a> & src)</td></tr>
+<tr class="memdesc:a2765416a5563c2d264c892aa6ab5a83c"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a2765416a5563c2d264c892aa6ab5a83c">More...</a><br /></td></tr>
+<tr class="separator:a2765416a5563c2d264c892aa6ab5a83c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5d486e3227ed5f73b791c4e202a168b4"><td class="memTemplParams" colspan="2">template<class T_functor > </td></tr>
+<tr class="memitem:a5d486e3227ed5f73b791c4e202a168b4"><td class="memTemplItemLeft" align="right" valign="top"> </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a5d486e3227ed5f73b791c4e202a168b4">slot</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:a5d486e3227ed5f73b791c4e202a168b4"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an arbitrary functor. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a5d486e3227ed5f73b791c4e202a168b4">More...</a><br /></td></tr>
+<tr class="separator:a5d486e3227ed5f73b791c4e202a168b4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad22e5b50e474d072bb17489e9342c478"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ad22e5b50e474d072bb17489e9342c478">slot</a> (<a class="el" href="classsigc_1_1slot.html">slot</a> && src)</td></tr>
+<tr class="memdesc:ad22e5b50e474d072bb17489e9342c478"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ad22e5b50e474d072bb17489e9342c478">More...</a><br /></td></tr>
+<tr class="separator:ad22e5b50e474d072bb17489e9342c478"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50efa6d5ba0613851a7aac56b98f7eb8"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot.html">slot</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a50efa6d5ba0613851a7aac56b98f7eb8">operator=</a> (const <a class="el" href="classsigc_1_1slot.html">slot</a> & src)</td></tr>
+<tr class="memdesc:a50efa6d5ba0613851a7aac56b98f7eb8"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a50efa6d5ba0613851a7aac56b98f7eb8">More...</a><br /></td></tr>
+<tr class="separator:a50efa6d5ba0613851a7aac56b98f7eb8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a88a00e43c5ed084441655b2f9e32c621"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot.html">slot</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a88a00e43c5ed084441655b2f9e32c621">operator=</a> (<a class="el" href="classsigc_1_1slot.html">slot</a> && src)</td></tr>
+<tr class="memdesc:a88a00e43c5ed084441655b2f9e32c621"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a88a00e43c5ed084441655b2f9e32c621">More...</a><br /></td></tr>
+<tr class="separator:a88a00e43c5ed084441655b2f9e32c621"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1slot1"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1slot1')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1slot1.html">sigc::slot1< T_return, T_arg1 ></a></td></tr>
+<tr class="memitem:aa8ac5eadba778c11a424e255889e67f6 inherit pub_methods_classsigc_1_1slot1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot1.html#aa8ac5eadba778c11a424e255889e67f6">slot1</a> ()</td></tr>
+<tr class="separator:aa8ac5eadba778c11a424e255889e67f6 inherit pub_methods_classsigc_1_1slot1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac6ecaff0a20a57d2168ea126e565e36a inherit pub_methods_classsigc_1_1slot1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot1.html#ac6ecaff0a20a57d2168ea126e565e36a">slot1</a> (const <a class="el" href="classsigc_1_1slot1.html">slot1</a> & src)</td></tr>
+<tr class="memdesc:ac6ecaff0a20a57d2168ea126e565e36a inherit pub_methods_classsigc_1_1slot1"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot1.html#ac6ecaff0a20a57d2168ea126e565e36a">More...</a><br /></td></tr>
+<tr class="separator:ac6ecaff0a20a57d2168ea126e565e36a inherit pub_methods_classsigc_1_1slot1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a20999708c6db16a3015beca7d4ad866e inherit pub_methods_classsigc_1_1slot1"><td class="memTemplParams" colspan="2">template<class T_functor > </td></tr>
+<tr class="memitem:a20999708c6db16a3015beca7d4ad866e inherit pub_methods_classsigc_1_1slot1"><td class="memTemplItemLeft" align="right" valign="top"> </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot1.html#a20999708c6db16a3015beca7d4ad866e">slot1</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:a20999708c6db16a3015beca7d4ad866e inherit pub_methods_classsigc_1_1slot1"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an arbitrary functor. <a href="classsigc_1_1slot1.html#a20999708c6db16a3015beca7d4ad866e">More...</a><br /></td></tr>
+<tr class="separator:a20999708c6db16a3015beca7d4ad866e inherit pub_methods_classsigc_1_1slot1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4ab8f18f97f843558f11adb9d1e8e478 inherit pub_methods_classsigc_1_1slot1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot1.html#a4ab8f18f97f843558f11adb9d1e8e478">slot1</a> (<a class="el" href="classsigc_1_1slot1.html">slot1</a> && src)</td></tr>
+<tr class="memdesc:a4ab8f18f97f843558f11adb9d1e8e478 inherit pub_methods_classsigc_1_1slot1"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot1.html#a4ab8f18f97f843558f11adb9d1e8e478">More...</a><br /></td></tr>
+<tr class="separator:a4ab8f18f97f843558f11adb9d1e8e478 inherit pub_methods_classsigc_1_1slot1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae9082daf31fdbb57da71e8c38a9ae1ab inherit pub_methods_classsigc_1_1slot1"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot1.html#ae9082daf31fdbb57da71e8c38a9ae1ab">operator()</a> (<a class="el" href="classsigc_1_1slot1.html#a4d81838957a9ccc6cb4c104706a37a89">arg1_type_</a> _A_a1) const</td></tr>
+<tr class="memdesc:ae9082daf31fdbb57da71e8c38a9ae1ab inherit pub_methods_classsigc_1_1slot1"><td class="mdescLeft"> </td><td class="mdescRight">Invoke the contained functor unless slot is in blocking state. <a href="classsigc_1_1slot1.html#ae9082daf31fdbb57da71e8c38a9ae1ab">More...</a><br /></td></tr>
+<tr class="separator:ae9082daf31fdbb57da71e8c38a9ae1ab inherit pub_methods_classsigc_1_1slot1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2e0d65cfc434718b6c5f7d7135ac384e inherit pub_methods_classsigc_1_1slot1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot1.html">slot1</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot1.html#a2e0d65cfc434718b6c5f7d7135ac384e">operator=</a> (const <a class="el" href="classsigc_1_1slot1.html">slot1</a> & src)</td></tr>
+<tr class="memdesc:a2e0d65cfc434718b6c5f7d7135ac384e inherit pub_methods_classsigc_1_1slot1"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot1.html#a2e0d65cfc434718b6c5f7d7135ac384e">More...</a><br /></td></tr>
+<tr class="separator:a2e0d65cfc434718b6c5f7d7135ac384e inherit pub_methods_classsigc_1_1slot1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a195acd57b42149a2faaeec4c6725825a inherit pub_methods_classsigc_1_1slot1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot1.html">slot1</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot1.html#a195acd57b42149a2faaeec4c6725825a">operator=</a> (<a class="el" href="classsigc_1_1slot1.html">slot1</a> && src)</td></tr>
+<tr class="memdesc:a195acd57b42149a2faaeec4c6725825a inherit pub_methods_classsigc_1_1slot1"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot1.html#a195acd57b42149a2faaeec4c6725825a">More...</a><br /></td></tr>
+<tr class="separator:a195acd57b42149a2faaeec4c6725825a inherit pub_methods_classsigc_1_1slot1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a> () noexcept</td></tr>
+<tr class="memdesc:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an empty slot. <a href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">More...</a><br /></td></tr>
+<tr class="separator:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">More...</a><br /></td></tr>
+<tr class="separator:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a> (rep_type * rep) noexcept</td></tr>
+<tr class="memdesc:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an existing slot_rep object. <a href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">More...</a><br /></td></tr>
+<tr class="separator:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">More...</a><br /></td></tr>
+<tr class="separator:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a> ()</td></tr>
+<tr class="separator:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the slot is detroyed. <a href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">More...</a><br /></td></tr>
+<tr class="separator:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state. <a href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">More...</a><br /></td></tr>
+<tr class="separator:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">More...</a><br /></td></tr>
+<tr class="separator:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a> ()</td></tr>
+<tr class="memdesc:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Disconnects the slot. <a href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">More...</a><br /></td></tr>
+<tr class="separator:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is invalid. <a href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">More...</a><br /></td></tr>
+<tr class="separator:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a> () const noexcept</td></tr>
+<tr class="memdesc:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Tests whether a slot is null, because the default constructor was used. <a href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">More...</a><br /></td></tr>
+<tr class="separator:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">operator=</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">More...</a><br /></td></tr>
+<tr class="separator:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">operator=</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">More...</a><br /></td></tr>
+<tr class="separator:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694" title="Add a callback that is executed (notified) when the slot is detroyed.">add_destroy_notify_callback()</a>. <a href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">More...</a><br /></td></tr>
+<tr class="separator:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a> (void * parent, void *(* cleanup)(void *)) const noexcept</td></tr>
+<tr class="memdesc:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the parent of this slot. <a href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">More...</a><br /></td></tr>
+<tr class="separator:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state. <a href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">More...</a><br /></td></tr>
+<tr class="separator:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_attribs_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td></tr>
+<tr class="memdesc:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Indicates whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">More...</a><br /></td></tr>
+<tr class="separator:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">rep_type * </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td></tr>
+<tr class="memdesc:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Typed slot_rep object that contains a functor. <a href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">More...</a><br /></td></tr>
+<tr class="separator:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_arg1><br />
+class sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot1.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot1</a> template. </p>
+<p>See the base class for useful methods. This is the template specialization of the unnumbered <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> template for 1 argument(s), specialized for different numbers of arguments This is possible because the template has default (nil) template types.</p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000196">Deprecated:</a></b></dt><dd>Please use the syntax similar to that used by std::function<>: </dd></dl>
+<div class="fragment"><div class="line"><a class="code" href="classsigc_1_1slot.html">sigc::slot</a><void(<span class="keywordtype">bool</span>, <span class="keywordtype">int</span>)> some_slot;</div>
+<div class="ttc" id="aclasssigc_1_1slot_html"><div class="ttname"><a href="classsigc_1_1slot.html">sigc::slot</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::slot# templates.</div><div class="ttdef"><b>Definition:</b> slot.h:1645</div></div>
+</div><!-- fragment --> </div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a2b6b5b8590577c765c7a32f7e619250a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2b6b5b8590577c765c7a32f7e619250a">◆ </a></span>parent_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="classsigc_1_1slot1.html">slot1</a><T_return, T_arg1> <a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a2b6b5b8590577c765c7a32f7e619250a">parent_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="ad34e10be904557368c241f53e972c8e7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad34e10be904557368c241f53e972c8e7">◆ </a></span>slot() <span class="overload">[1/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a5d486e3227ed5f73b791c4e202a168b4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5d486e3227ed5f73b791c4e202a168b4">◆ </a></span>slot() <span class="overload">[2/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+<div class="memtemplate">
+template <class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot from an arbitrary functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>The desired functor the new slot should be assigned to. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a2765416a5563c2d264c892aa6ab5a83c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2765416a5563c2d264c892aa6ab5a83c">◆ </a></span>slot() <span class="overload">[3/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, copying an existing one. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="ad22e5b50e474d072bb17489e9342c478"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad22e5b50e474d072bb17489e9342c478">◆ </a></span>slot() <span class="overload">[4/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, moving an existing one. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a50efa6d5ba0613851a7aac56b98f7eb8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a50efa6d5ba0613851a7aac56b98f7eb8">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">slot</a>& <a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a copy from another slot. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to make a copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+<a id="a88a00e43c5ed084441655b2f9e32c621"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a88a00e43c5ed084441655b2f9e32c621">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">slot</a>& <a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, T_arg1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a move from another slot. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil >" name="sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::slot1 template." alt="" coords="9,244,163,300"/>
+<area shape="rect" id="node2" href="$classsigc_1_1slot1.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="5,155,167,196"/>
+<area shape="rect" id="node3" href="$classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="27,80,145,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="16,5,156,32"/>
+</map>
--- /dev/null
+2188ec8092bf77ab07b279610a08449a
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">slot< T_return, nil, nil, nil, nil, nil, nil, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot0.html#afa926436a4b0734f0adc2a485ccfe36a">operator()</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1slot0.html">sigc::slot0< T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a62c6b78bd545f7b6a2b0b85a6c3e6b00">operator=</a>(const slot & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#aba4c957436ba517b8b21a58e75ef9253">operator=</a>(slot && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot0.html#a49bba0540dcc76fb19e49d19a1acd563">sigc::slot0::operator=</a>(const slot0 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot0.html">sigc::slot0< T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot0.html#a95205051379e5d5657bac78c9b3b8d49">sigc::slot0::operator=</a>(slot0 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot0.html">sigc::slot0< T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">sigc::slot_base::operator=</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">sigc::slot_base::operator=</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a9937c7fbdb8be4e387fddcebf328fa41">parent_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot0.html#aca0c967b605e09d5a87015d95e93d4f7">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot0.html">sigc::slot0< T_return ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a>(void * parent, void *(* cleanup)(void *)) const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#abdb48282bb8b1b5404fcea6474eca5a5">slot</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ad35c264a95bfb4f29ed1fac4fda05a48">slot</a>(const T_functor & _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a9312dc3f121832083362b21334b939d2">slot</a>(const slot & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#aaf79a4f6ed84e20f9a800daa4f625d57">slot</a>(slot && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot0.html#a8681082ecd439d5b294922e4d27a3f49">slot0</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot0.html">sigc::slot0< T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot0.html#a83a247c06b93ef644bdfe0bf119929c0">slot0</a>(const T_functor & _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1slot0.html">sigc::slot0< T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot0.html#acce9a5d9a4f939e405383092ba717f72">slot0</a>(const slot0 & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot0.html">sigc::slot0< T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot0.html#ac93b53e3d90df14b2b003ad0c685b160">slot0</a>(slot0 && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot0.html">sigc::slot0< T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a>(rep_type * rep) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">slot< T_return, nil, nil, nil, nil, nil, nil, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot0.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot0</a> template.
+ <a href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/slot.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4__inherit__graph.png" border="0" usemap="#asigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map" id="asigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map">
+<area shape="rect" title="Convenience wrapper for the numbered sigc::slot0 template." alt="" coords="15,229,168,285"/>
+<area shape="rect" href="classsigc_1_1slot0.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="5,155,177,181"/>
+<area shape="rect" href="classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="32,80,151,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="21,5,161,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a9937c7fbdb8be4e387fddcebf328fa41"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="classsigc_1_1slot0.html">slot0</a>< T_return > </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a9937c7fbdb8be4e387fddcebf328fa41">parent_type</a></td></tr>
+<tr class="separator:a9937c7fbdb8be4e387fddcebf328fa41"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1slot0"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1slot0')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1slot0.html">sigc::slot0< T_return ></a></td></tr>
+<tr class="memitem:aca0c967b605e09d5a87015d95e93d4f7 inherit pub_types_classsigc_1_1slot0"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot0.html#aca0c967b605e09d5a87015d95e93d4f7">result_type</a></td></tr>
+<tr class="separator:aca0c967b605e09d5a87015d95e93d4f7 inherit pub_types_classsigc_1_1slot0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">trackable::func_destroy_notify</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a></td></tr>
+<tr class="separator:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:abdb48282bb8b1b5404fcea6474eca5a5"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#abdb48282bb8b1b5404fcea6474eca5a5">slot</a> ()</td></tr>
+<tr class="separator:abdb48282bb8b1b5404fcea6474eca5a5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9312dc3f121832083362b21334b939d2"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a9312dc3f121832083362b21334b939d2">slot</a> (const <a class="el" href="classsigc_1_1slot.html">slot</a> & src)</td></tr>
+<tr class="memdesc:a9312dc3f121832083362b21334b939d2"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a9312dc3f121832083362b21334b939d2">More...</a><br /></td></tr>
+<tr class="separator:a9312dc3f121832083362b21334b939d2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad35c264a95bfb4f29ed1fac4fda05a48"><td class="memTemplParams" colspan="2">template<class T_functor > </td></tr>
+<tr class="memitem:ad35c264a95bfb4f29ed1fac4fda05a48"><td class="memTemplItemLeft" align="right" valign="top"> </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ad35c264a95bfb4f29ed1fac4fda05a48">slot</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:ad35c264a95bfb4f29ed1fac4fda05a48"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an arbitrary functor. <a href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ad35c264a95bfb4f29ed1fac4fda05a48">More...</a><br /></td></tr>
+<tr class="separator:ad35c264a95bfb4f29ed1fac4fda05a48"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aaf79a4f6ed84e20f9a800daa4f625d57"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#aaf79a4f6ed84e20f9a800daa4f625d57">slot</a> (<a class="el" href="classsigc_1_1slot.html">slot</a> && src)</td></tr>
+<tr class="memdesc:aaf79a4f6ed84e20f9a800daa4f625d57"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#aaf79a4f6ed84e20f9a800daa4f625d57">More...</a><br /></td></tr>
+<tr class="separator:aaf79a4f6ed84e20f9a800daa4f625d57"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a62c6b78bd545f7b6a2b0b85a6c3e6b00"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot.html">slot</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a62c6b78bd545f7b6a2b0b85a6c3e6b00">operator=</a> (const <a class="el" href="classsigc_1_1slot.html">slot</a> & src)</td></tr>
+<tr class="memdesc:a62c6b78bd545f7b6a2b0b85a6c3e6b00"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a62c6b78bd545f7b6a2b0b85a6c3e6b00">More...</a><br /></td></tr>
+<tr class="separator:a62c6b78bd545f7b6a2b0b85a6c3e6b00"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba4c957436ba517b8b21a58e75ef9253"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot.html">slot</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#aba4c957436ba517b8b21a58e75ef9253">operator=</a> (<a class="el" href="classsigc_1_1slot.html">slot</a> && src)</td></tr>
+<tr class="memdesc:aba4c957436ba517b8b21a58e75ef9253"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#aba4c957436ba517b8b21a58e75ef9253">More...</a><br /></td></tr>
+<tr class="separator:aba4c957436ba517b8b21a58e75ef9253"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1slot0"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1slot0')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1slot0.html">sigc::slot0< T_return ></a></td></tr>
+<tr class="memitem:a8681082ecd439d5b294922e4d27a3f49 inherit pub_methods_classsigc_1_1slot0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot0.html#a8681082ecd439d5b294922e4d27a3f49">slot0</a> ()</td></tr>
+<tr class="separator:a8681082ecd439d5b294922e4d27a3f49 inherit pub_methods_classsigc_1_1slot0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acce9a5d9a4f939e405383092ba717f72 inherit pub_methods_classsigc_1_1slot0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot0.html#acce9a5d9a4f939e405383092ba717f72">slot0</a> (const <a class="el" href="classsigc_1_1slot0.html">slot0</a> & src)</td></tr>
+<tr class="memdesc:acce9a5d9a4f939e405383092ba717f72 inherit pub_methods_classsigc_1_1slot0"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot0.html#acce9a5d9a4f939e405383092ba717f72">More...</a><br /></td></tr>
+<tr class="separator:acce9a5d9a4f939e405383092ba717f72 inherit pub_methods_classsigc_1_1slot0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a83a247c06b93ef644bdfe0bf119929c0 inherit pub_methods_classsigc_1_1slot0"><td class="memTemplParams" colspan="2">template<class T_functor > </td></tr>
+<tr class="memitem:a83a247c06b93ef644bdfe0bf119929c0 inherit pub_methods_classsigc_1_1slot0"><td class="memTemplItemLeft" align="right" valign="top"> </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot0.html#a83a247c06b93ef644bdfe0bf119929c0">slot0</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:a83a247c06b93ef644bdfe0bf119929c0 inherit pub_methods_classsigc_1_1slot0"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an arbitrary functor. <a href="classsigc_1_1slot0.html#a83a247c06b93ef644bdfe0bf119929c0">More...</a><br /></td></tr>
+<tr class="separator:a83a247c06b93ef644bdfe0bf119929c0 inherit pub_methods_classsigc_1_1slot0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac93b53e3d90df14b2b003ad0c685b160 inherit pub_methods_classsigc_1_1slot0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot0.html#ac93b53e3d90df14b2b003ad0c685b160">slot0</a> (<a class="el" href="classsigc_1_1slot0.html">slot0</a> && src)</td></tr>
+<tr class="memdesc:ac93b53e3d90df14b2b003ad0c685b160 inherit pub_methods_classsigc_1_1slot0"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot0.html#ac93b53e3d90df14b2b003ad0c685b160">More...</a><br /></td></tr>
+<tr class="separator:ac93b53e3d90df14b2b003ad0c685b160 inherit pub_methods_classsigc_1_1slot0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa926436a4b0734f0adc2a485ccfe36a inherit pub_methods_classsigc_1_1slot0"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot0.html#afa926436a4b0734f0adc2a485ccfe36a">operator()</a> () const</td></tr>
+<tr class="memdesc:afa926436a4b0734f0adc2a485ccfe36a inherit pub_methods_classsigc_1_1slot0"><td class="mdescLeft"> </td><td class="mdescRight">Invoke the contained functor unless slot is in blocking state. <a href="classsigc_1_1slot0.html#afa926436a4b0734f0adc2a485ccfe36a">More...</a><br /></td></tr>
+<tr class="separator:afa926436a4b0734f0adc2a485ccfe36a inherit pub_methods_classsigc_1_1slot0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a49bba0540dcc76fb19e49d19a1acd563 inherit pub_methods_classsigc_1_1slot0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot0.html">slot0</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot0.html#a49bba0540dcc76fb19e49d19a1acd563">operator=</a> (const <a class="el" href="classsigc_1_1slot0.html">slot0</a> & src)</td></tr>
+<tr class="memdesc:a49bba0540dcc76fb19e49d19a1acd563 inherit pub_methods_classsigc_1_1slot0"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot0.html#a49bba0540dcc76fb19e49d19a1acd563">More...</a><br /></td></tr>
+<tr class="separator:a49bba0540dcc76fb19e49d19a1acd563 inherit pub_methods_classsigc_1_1slot0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a95205051379e5d5657bac78c9b3b8d49 inherit pub_methods_classsigc_1_1slot0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot0.html">slot0</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot0.html#a95205051379e5d5657bac78c9b3b8d49">operator=</a> (<a class="el" href="classsigc_1_1slot0.html">slot0</a> && src)</td></tr>
+<tr class="memdesc:a95205051379e5d5657bac78c9b3b8d49 inherit pub_methods_classsigc_1_1slot0"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot0.html#a95205051379e5d5657bac78c9b3b8d49">More...</a><br /></td></tr>
+<tr class="separator:a95205051379e5d5657bac78c9b3b8d49 inherit pub_methods_classsigc_1_1slot0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a> () noexcept</td></tr>
+<tr class="memdesc:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an empty slot. <a href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">More...</a><br /></td></tr>
+<tr class="separator:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">More...</a><br /></td></tr>
+<tr class="separator:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a> (rep_type * rep) noexcept</td></tr>
+<tr class="memdesc:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an existing slot_rep object. <a href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">More...</a><br /></td></tr>
+<tr class="separator:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">More...</a><br /></td></tr>
+<tr class="separator:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a> ()</td></tr>
+<tr class="separator:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the slot is detroyed. <a href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">More...</a><br /></td></tr>
+<tr class="separator:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state. <a href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">More...</a><br /></td></tr>
+<tr class="separator:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">More...</a><br /></td></tr>
+<tr class="separator:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a> ()</td></tr>
+<tr class="memdesc:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Disconnects the slot. <a href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">More...</a><br /></td></tr>
+<tr class="separator:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is invalid. <a href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">More...</a><br /></td></tr>
+<tr class="separator:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a> () const noexcept</td></tr>
+<tr class="memdesc:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Tests whether a slot is null, because the default constructor was used. <a href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">More...</a><br /></td></tr>
+<tr class="separator:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">operator=</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">More...</a><br /></td></tr>
+<tr class="separator:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">operator=</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">More...</a><br /></td></tr>
+<tr class="separator:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694" title="Add a callback that is executed (notified) when the slot is detroyed.">add_destroy_notify_callback()</a>. <a href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">More...</a><br /></td></tr>
+<tr class="separator:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a> (void * parent, void *(* cleanup)(void *)) const noexcept</td></tr>
+<tr class="memdesc:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the parent of this slot. <a href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">More...</a><br /></td></tr>
+<tr class="separator:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state. <a href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">More...</a><br /></td></tr>
+<tr class="separator:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_attribs_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td></tr>
+<tr class="memdesc:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Indicates whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">More...</a><br /></td></tr>
+<tr class="separator:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">rep_type * </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td></tr>
+<tr class="memdesc:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Typed slot_rep object that contains a functor. <a href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">More...</a><br /></td></tr>
+<tr class="separator:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return><br />
+class sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil ></h3>
+
+<p>Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot0.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot0</a> template. </p>
+<p>See the base class for useful methods. This is the template specialization of the unnumbered <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> template for 0 argument(s), specialized for different numbers of arguments This is possible because the template has default (nil) template types.</p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000195">Deprecated:</a></b></dt><dd>Please use the syntax similar to that used by std::function<>: </dd></dl>
+<div class="fragment"><div class="line"><a class="code" href="classsigc_1_1slot.html">sigc::slot</a><void(<span class="keywordtype">bool</span>, <span class="keywordtype">int</span>)> some_slot;</div>
+<div class="ttc" id="aclasssigc_1_1slot_html"><div class="ttname"><a href="classsigc_1_1slot.html">sigc::slot</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::slot# templates.</div><div class="ttdef"><b>Definition:</b> slot.h:1645</div></div>
+</div><!-- fragment --> </div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a9937c7fbdb8be4e387fddcebf328fa41"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9937c7fbdb8be4e387fddcebf328fa41">◆ </a></span>parent_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="classsigc_1_1slot0.html">slot0</a><T_return> <a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a9937c7fbdb8be4e387fddcebf328fa41">parent_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="abdb48282bb8b1b5404fcea6474eca5a5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abdb48282bb8b1b5404fcea6474eca5a5">◆ </a></span>slot() <span class="overload">[1/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ad35c264a95bfb4f29ed1fac4fda05a48"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad35c264a95bfb4f29ed1fac4fda05a48">◆ </a></span>slot() <span class="overload">[2/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<div class="memtemplate">
+template <class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot from an arbitrary functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>The desired functor the new slot should be assigned to. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a9312dc3f121832083362b21334b939d2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9312dc3f121832083362b21334b939d2">◆ </a></span>slot() <span class="overload">[3/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, copying an existing one. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="aaf79a4f6ed84e20f9a800daa4f625d57"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aaf79a4f6ed84e20f9a800daa4f625d57">◆ </a></span>slot() <span class="overload">[4/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, moving an existing one. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a62c6b78bd545f7b6a2b0b85a6c3e6b00"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a62c6b78bd545f7b6a2b0b85a6c3e6b00">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">slot</a>& <a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a copy from another slot. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to make a copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+<a id="aba4c957436ba517b8b21a58e75ef9253"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aba4c957436ba517b8b21a58e75ef9253">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">slot</a>& <a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> > && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a move from another slot. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil >" name="sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::slot0 template." alt="" coords="15,229,168,285"/>
+<area shape="rect" id="node2" href="$classsigc_1_1slot0.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="5,155,177,181"/>
+<area shape="rect" id="node3" href="$classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="32,80,151,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="21,5,161,32"/>
+</map>
--- /dev/null
+b6f65523017043c86340e6532c74f489
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html">slot< T_return(T_arg...)></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::slot< T_return(T_arg...)> Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html">sigc::slot< T_return(T_arg...)></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#a4038d1a1c7a34bbb344b61a8f43c23f6">operator()</a>(type_trait_take_t< T_arg >... _A_a) const</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html">sigc::slot< T_return(T_arg...)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#a34e1ec92ebbc3ee4dbc8acdeb525c12c">operator=</a>(const slot & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html">sigc::slot< T_return(T_arg...)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#a22759a1af0d37b9e7432bbb046ceff8a">operator=</a>(slot && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html">sigc::slot< T_return(T_arg...)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">sigc::slot_base::operator=</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">sigc::slot_base::operator=</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#af593e79280c004b6ef8f4722953df0c4">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html">sigc::slot< T_return(T_arg...)></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a>(void * parent, void *(* cleanup)(void *)) const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#add0d65ea6dc554733e766b3510c89a3a">slot</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html">sigc::slot< T_return(T_arg...)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#a8c7a2fb604a0a9495bfa2850bb3520f5">slot</a>(const T_functor & _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html">sigc::slot< T_return(T_arg...)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#ad1e5bc73a259ee666eb8d11d9e48d1d7">slot</a>(const slot & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html">sigc::slot< T_return(T_arg...)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#ae7d852d9ac2c9a6a37564a0f4aed3872">slot</a>(slot && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html">sigc::slot< T_return(T_arg...)></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a>(rep_type * rep) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::slot< T_return(T_arg...)> Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html">slot< T_return(T_arg...)></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::slot< T_return(T_arg...)> Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__slot.html">Slots</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Converts an arbitrary functor to a unified type which is opaque.
+ <a href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/slot.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::slot< T_return(T_arg...)>:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4__inherit__graph.png" border="0" usemap="#asigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4_inherit__map" id="asigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4_inherit__map">
+<area shape="rect" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="5,155,155,196"/>
+<area shape="rect" href="classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="21,80,139,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="10,5,150,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:af593e79280c004b6ef8f4722953df0c4"><td class="memItemLeft" align="right" valign="top">using </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#af593e79280c004b6ef8f4722953df0c4">result_type</a> = T_return</td></tr>
+<tr class="separator:af593e79280c004b6ef8f4722953df0c4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">trackable::func_destroy_notify</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a></td></tr>
+<tr class="separator:a7e1a0c2fe43a42187810e8997abeb341 inherit pub_types_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:add0d65ea6dc554733e766b3510c89a3a"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#add0d65ea6dc554733e766b3510c89a3a">slot</a> ()</td></tr>
+<tr class="separator:add0d65ea6dc554733e766b3510c89a3a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1e5bc73a259ee666eb8d11d9e48d1d7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#ad1e5bc73a259ee666eb8d11d9e48d1d7">slot</a> (const <a class="el" href="classsigc_1_1slot.html">slot</a> & src)</td></tr>
+<tr class="memdesc:ad1e5bc73a259ee666eb8d11d9e48d1d7"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#ad1e5bc73a259ee666eb8d11d9e48d1d7">More...</a><br /></td></tr>
+<tr class="separator:ad1e5bc73a259ee666eb8d11d9e48d1d7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8c7a2fb604a0a9495bfa2850bb3520f5"><td class="memTemplParams" colspan="2">template<class T_functor > </td></tr>
+<tr class="memitem:a8c7a2fb604a0a9495bfa2850bb3520f5"><td class="memTemplItemLeft" align="right" valign="top"> </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#a8c7a2fb604a0a9495bfa2850bb3520f5">slot</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:a8c7a2fb604a0a9495bfa2850bb3520f5"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an arbitrary functor. <a href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#a8c7a2fb604a0a9495bfa2850bb3520f5">More...</a><br /></td></tr>
+<tr class="separator:a8c7a2fb604a0a9495bfa2850bb3520f5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae7d852d9ac2c9a6a37564a0f4aed3872"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#ae7d852d9ac2c9a6a37564a0f4aed3872">slot</a> (<a class="el" href="classsigc_1_1slot.html">slot</a> && src)</td></tr>
+<tr class="memdesc:ae7d852d9ac2c9a6a37564a0f4aed3872"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#ae7d852d9ac2c9a6a37564a0f4aed3872">More...</a><br /></td></tr>
+<tr class="separator:ae7d852d9ac2c9a6a37564a0f4aed3872"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4038d1a1c7a34bbb344b61a8f43c23f6"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#a4038d1a1c7a34bbb344b61a8f43c23f6">operator()</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg >... _A_a) const</td></tr>
+<tr class="memdesc:a4038d1a1c7a34bbb344b61a8f43c23f6"><td class="mdescLeft"> </td><td class="mdescRight">Invoke the contained functor unless slot is in blocking state. <a href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#a4038d1a1c7a34bbb344b61a8f43c23f6">More...</a><br /></td></tr>
+<tr class="separator:a4038d1a1c7a34bbb344b61a8f43c23f6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a34e1ec92ebbc3ee4dbc8acdeb525c12c"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot.html">slot</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#a34e1ec92ebbc3ee4dbc8acdeb525c12c">operator=</a> (const <a class="el" href="classsigc_1_1slot.html">slot</a> & src)</td></tr>
+<tr class="memdesc:a34e1ec92ebbc3ee4dbc8acdeb525c12c"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#a34e1ec92ebbc3ee4dbc8acdeb525c12c">More...</a><br /></td></tr>
+<tr class="separator:a34e1ec92ebbc3ee4dbc8acdeb525c12c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a22759a1af0d37b9e7432bbb046ceff8a"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot.html">slot</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#a22759a1af0d37b9e7432bbb046ceff8a">operator=</a> (<a class="el" href="classsigc_1_1slot.html">slot</a> && src)</td></tr>
+<tr class="memdesc:a22759a1af0d37b9e7432bbb046ceff8a"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#a22759a1af0d37b9e7432bbb046ceff8a">More...</a><br /></td></tr>
+<tr class="separator:a22759a1af0d37b9e7432bbb046ceff8a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a> () noexcept</td></tr>
+<tr class="memdesc:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an empty slot. <a href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">More...</a><br /></td></tr>
+<tr class="separator:a182d5db71ef371838c73bcf1c135cd9a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">More...</a><br /></td></tr>
+<tr class="separator:aadcbb54832b5207bddf89ac5433b531a inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a> (rep_type * rep) noexcept</td></tr>
+<tr class="memdesc:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an existing slot_rep object. <a href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">More...</a><br /></td></tr>
+<tr class="separator:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">More...</a><br /></td></tr>
+<tr class="separator:ad1fee67a5885e424c275ad0f48fc81b1 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a> ()</td></tr>
+<tr class="separator:a75c18c50860f63fb020fc2953576ea57 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the slot is detroyed. <a href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">More...</a><br /></td></tr>
+<tr class="separator:a8e37cc8f4b57898a288680e59bea2694 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state. <a href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">More...</a><br /></td></tr>
+<tr class="separator:a657a8473164c963a5ca4828c88121bb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">More...</a><br /></td></tr>
+<tr class="separator:a2f266b6147c4a6bbc5b68994d2dc1517 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a> ()</td></tr>
+<tr class="memdesc:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Disconnects the slot. <a href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">More...</a><br /></td></tr>
+<tr class="separator:a4042d221f7f07a7394d2eb0f14db2857 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is invalid. <a href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">More...</a><br /></td></tr>
+<tr class="separator:ae6ac6ca962a1f6a7506d0817165b5cef inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a> () const noexcept</td></tr>
+<tr class="memdesc:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Tests whether a slot is null, because the default constructor was used. <a href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">More...</a><br /></td></tr>
+<tr class="separator:a90d4d7d6037973a94d7dfd7ba9a5feb9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">operator=</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">More...</a><br /></td></tr>
+<tr class="separator:a19522528264f1646f8ed982b0042ffad inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">operator=</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">More...</a><br /></td></tr>
+<tr class="separator:a64e36f28ee61a94c0496fe76f6b3e813 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694" title="Add a callback that is executed (notified) when the slot is detroyed.">add_destroy_notify_callback()</a>. <a href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">More...</a><br /></td></tr>
+<tr class="separator:a69c55dedaa35626f288754d55b3da66c inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a> (void * parent, void *(* cleanup)(void *)) const noexcept</td></tr>
+<tr class="memdesc:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Sets the parent of this slot. <a href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">More...</a><br /></td></tr>
+<tr class="separator:aa7d281de451d5f47923f4ff1c5b7f2c9 inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state. <a href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">More...</a><br /></td></tr>
+<tr class="separator:a25ad0bd4d2cea4dbfcd09f7d393d266d inherit pub_methods_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_attribs_classsigc_1_1slot__base"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_classsigc_1_1slot__base')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memitem:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td></tr>
+<tr class="memdesc:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Indicates whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">More...</a><br /></td></tr>
+<tr class="separator:a9dc4958860c0f8300b461a743b7f2a2b inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memItemLeft" align="right" valign="top">rep_type * </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td></tr>
+<tr class="memdesc:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="mdescLeft"> </td><td class="mdescRight">Typed slot_rep object that contains a functor. <a href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">More...</a><br /></td></tr>
+<tr class="separator:aa482f7dfc73c6950abde0fd51b3125b5 inherit pub_attribs_classsigc_1_1slot__base"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class... T_arg><br />
+class sigc::slot< T_return(T_arg...)></h3>
+
+<p>Converts an arbitrary functor to a unified type which is opaque. </p>
+<p><a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> itself is a functor or, to be more precise, a closure. It contains a single, arbitrary functor (or closure) that is executed in <a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#a4038d1a1c7a34bbb344b61a8f43c23f6" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>.</p>
+<p>The template arguments determine the function signature of <a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#a4038d1a1c7a34bbb344b61a8f43c23f6" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>:</p><ul>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#a4038d1a1c7a34bbb344b61a8f43c23f6" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>.</li>
+<li><em>T_arg</em> Argument types used in the definition of <a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#a4038d1a1c7a34bbb344b61a8f43c23f6" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a>.</li>
+</ul>
+<p>For instance, to declare a slot that returns void and takes two parameters of bool and int: </p><div class="fragment"><div class="line"><a class="code" href="classsigc_1_1slot.html">sigc::slot</a><void(<span class="keywordtype">bool</span>, <span class="keywordtype">int</span>)> some_slot;</div>
+<div class="ttc" id="aclasssigc_1_1slot_html"><div class="ttname"><a href="classsigc_1_1slot.html">sigc::slot</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::slot# templates.</div><div class="ttdef"><b>Definition:</b> slot.h:1645</div></div>
+</div><!-- fragment --><p>Alternatively, you may use this syntax: </p><div class="fragment"><div class="line"><a class="code" href="classsigc_1_1slot.html">sigc::slot<void, bool, int></a> some_slot;</div>
+</div><!-- fragment --><p>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. <a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9" title="Sets the blocking state.">block()</a> and <a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d" title="Unsets the blocking state.">unblock()</a> can be used to block the functor's invocation from <a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#a4038d1a1c7a34bbb344b61a8f43c23f6" title="Invoke the contained functor unless slot is in blocking state.">operator()()</a> temporarily. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="af593e79280c004b6ef8f4722953df0c4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af593e79280c004b6ef8f4722953df0c4">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class... T_arg> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">using <a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return(T_arg...)>::<a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#af593e79280c004b6ef8f4722953df0c4">result_type</a> = T_return</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="add0d65ea6dc554733e766b3510c89a3a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#add0d65ea6dc554733e766b3510c89a3a">◆ </a></span>slot() <span class="overload">[1/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class... T_arg> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return(T_arg...)>::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a8c7a2fb604a0a9495bfa2850bb3520f5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8c7a2fb604a0a9495bfa2850bb3520f5">◆ </a></span>slot() <span class="overload">[2/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class... T_arg> </div>
+<div class="memtemplate">
+template <class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return(T_arg...)>::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot from an arbitrary functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>The desired functor the new slot should be assigned to. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="ad1e5bc73a259ee666eb8d11d9e48d1d7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad1e5bc73a259ee666eb8d11d9e48d1d7">◆ </a></span>slot() <span class="overload">[3/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class... T_arg> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return(T_arg...)>::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg...)> & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, copying an existing one. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="ae7d852d9ac2c9a6a37564a0f4aed3872"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae7d852d9ac2c9a6a37564a0f4aed3872">◆ </a></span>slot() <span class="overload">[4/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class... T_arg> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return(T_arg...)>::<a class="el" href="classsigc_1_1slot.html">slot</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg...)> && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, moving an existing one. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a4038d1a1c7a34bbb344b61a8f43c23f6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4038d1a1c7a34bbb344b61a8f43c23f6">◆ </a></span>operator()()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class... T_arg> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return(T_arg...)>::operator() </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg >... </td>
+ <td class="paramname"><em>_A_a</em></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invoke the contained functor unless slot is in blocking state. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a</td><td>Arguments to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a34e1ec92ebbc3ee4dbc8acdeb525c12c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a34e1ec92ebbc3ee4dbc8acdeb525c12c">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class... T_arg> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">slot</a>& <a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return(T_arg...)>::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg...)> & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a copy from another slot. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to make a copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+<a id="a22759a1af0d37b9e7432bbb046ceff8a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a22759a1af0d37b9e7432bbb046ceff8a">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class... T_arg> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot.html">slot</a>& <a class="el" href="classsigc_1_1slot.html">sigc::slot</a>< T_return(T_arg...)>::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot.html">slot</a>< T_return(T_arg...)> && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a move from another slot. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::slot< T_return(T_arg...)>" name="sigc::slot< T_return(T_arg...)>">
+<area shape="rect" id="node1" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="5,155,155,196"/>
+<area shape="rect" id="node2" href="$classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="21,80,139,107"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="10,5,150,32"/>
+</map>
--- /dev/null
+48c0df43647b6a02fa20537d3e45b35a
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::slot_base Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a>() const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">operator=</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">operator=</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a>(void * parent, void *(* cleanup)(void *)) const noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a>(rep_type * rep) noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a>(const slot_base & src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a>(slot_base && src)</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a>() noexcept</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a>()</td><td class="entry"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::slot_base Class Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="classsigc_1_1slot__base-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::slot_base Class Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__slot.html">Slots</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Base type for slots.
+ <a href="classsigc_1_1slot__base.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/slot_base.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::slot_base:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1slot__base__inherit__graph.png" border="0" usemap="#asigc_1_1slot__base_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1slot__base_inherit__map" id="asigc_1_1slot__base_inherit__map">
+<area shape="rect" title="Base type for slots." alt="" coords="193,389,312,415"/>
+<area shape="rect" href="classsigc_1_1slot7.html" title=" " alt="" coords="374,23,535,79"/>
+<area shape="rect" href="classsigc_1_1slot0.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="369,126,541,153"/>
+<area shape="rect" href="classsigc_1_1slot1.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="374,195,535,236"/>
+<area shape="rect" href="classsigc_1_1slot2.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="374,272,535,313"/>
+<area shape="rect" href="classsigc_1_1slot3.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="360,344,549,385"/>
+<area shape="rect" href="classsigc_1_1slot4.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="365,410,544,466"/>
+<area shape="rect" href="classsigc_1_1slot5.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="365,490,544,546"/>
+<area shape="rect" href="classsigc_1_1slot6.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="360,570,549,626"/>
+<area shape="rect" href="classsigc_1_1slot7.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="365,651,544,721"/>
+<area shape="rect" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="380,745,529,787"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,389,145,415"/>
+<area shape="rect" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates." alt="" coords="615,5,793,76"/>
+<area shape="rect" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot0 template." alt="" coords="627,101,781,157"/>
+<area shape="rect" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot1 template." alt="" coords="627,181,781,237"/>
+<area shape="rect" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot2 template." alt="" coords="627,261,781,317"/>
+<area shape="rect" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot3 template." alt="" coords="615,341,793,397"/>
+<area shape="rect" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot4 template." alt="" coords="615,421,793,477"/>
+<area shape="rect" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot5 template." alt="" coords="611,501,797,557"/>
+<area shape="rect" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot6 template." alt="" coords="597,581,811,637"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a7e1a0c2fe43a42187810e8997abeb341"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">trackable::func_destroy_notify</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a></td></tr>
+<tr class="separator:a7e1a0c2fe43a42187810e8997abeb341"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a182d5db71ef371838c73bcf1c135cd9a"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">slot_base</a> () noexcept</td></tr>
+<tr class="memdesc:a182d5db71ef371838c73bcf1c135cd9a"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an empty slot. <a href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">More...</a><br /></td></tr>
+<tr class="separator:a182d5db71ef371838c73bcf1c135cd9a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aadcbb54832b5207bddf89ac5433b531a"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">slot_base</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:aadcbb54832b5207bddf89ac5433b531a"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, copying an existing one. <a href="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a">More...</a><br /></td></tr>
+<tr class="separator:aadcbb54832b5207bddf89ac5433b531a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">slot_base</a> (rep_type * rep) noexcept</td></tr>
+<tr class="memdesc:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot from an existing slot_rep object. <a href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">More...</a><br /></td></tr>
+<tr class="separator:a5fbc2bf38a0d9ebcbe13d578d2b3d5a1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1fee67a5885e424c275ad0f48fc81b1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">slot_base</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:ad1fee67a5885e424c275ad0f48fc81b1"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a slot, moving an existing one. <a href="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1">More...</a><br /></td></tr>
+<tr class="separator:ad1fee67a5885e424c275ad0f48fc81b1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75c18c50860f63fb020fc2953576ea57"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">~slot_base</a> ()</td></tr>
+<tr class="separator:a75c18c50860f63fb020fc2953576ea57"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8e37cc8f4b57898a288680e59bea2694"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:a8e37cc8f4b57898a288680e59bea2694"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the slot is detroyed. <a href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">More...</a><br /></td></tr>
+<tr class="separator:a8e37cc8f4b57898a288680e59bea2694"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a657a8473164c963a5ca4828c88121bb9"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a657a8473164c963a5ca4828c88121bb9"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state. <a href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">More...</a><br /></td></tr>
+<tr class="separator:a657a8473164c963a5ca4828c88121bb9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2f266b6147c4a6bbc5b68994d2dc1517"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a2f266b6147c4a6bbc5b68994d2dc1517"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">More...</a><br /></td></tr>
+<tr class="separator:a2f266b6147c4a6bbc5b68994d2dc1517"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4042d221f7f07a7394d2eb0f14db2857"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">disconnect</a> ()</td></tr>
+<tr class="memdesc:a4042d221f7f07a7394d2eb0f14db2857"><td class="mdescLeft"> </td><td class="mdescRight">Disconnects the slot. <a href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">More...</a><br /></td></tr>
+<tr class="separator:a4042d221f7f07a7394d2eb0f14db2857"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae6ac6ca962a1f6a7506d0817165b5cef"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:ae6ac6ca962a1f6a7506d0817165b5cef"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the slot is invalid. <a href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">More...</a><br /></td></tr>
+<tr class="separator:ae6ac6ca962a1f6a7506d0817165b5cef"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90d4d7d6037973a94d7dfd7ba9a5feb9"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">operator bool</a> () const noexcept</td></tr>
+<tr class="memdesc:a90d4d7d6037973a94d7dfd7ba9a5feb9"><td class="mdescLeft"> </td><td class="mdescRight">Tests whether a slot is null, because the default constructor was used. <a href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">More...</a><br /></td></tr>
+<tr class="separator:a90d4d7d6037973a94d7dfd7ba9a5feb9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a19522528264f1646f8ed982b0042ffad"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">operator=</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & src)</td></tr>
+<tr class="memdesc:a19522528264f1646f8ed982b0042ffad"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a copy from another slot. <a href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">More...</a><br /></td></tr>
+<tr class="separator:a19522528264f1646f8ed982b0042ffad"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a64e36f28ee61a94c0496fe76f6b3e813"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">operator=</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && src)</td></tr>
+<tr class="memdesc:a64e36f28ee61a94c0496fe76f6b3e813"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this slot, making a move from another slot. <a href="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813">More...</a><br /></td></tr>
+<tr class="separator:a64e36f28ee61a94c0496fe76f6b3e813"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a69c55dedaa35626f288754d55b3da66c"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:a69c55dedaa35626f288754d55b3da66c"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694" title="Add a callback that is executed (notified) when the slot is detroyed.">add_destroy_notify_callback()</a>. <a href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">More...</a><br /></td></tr>
+<tr class="separator:a69c55dedaa35626f288754d55b3da66c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa7d281de451d5f47923f4ff1c5b7f2c9"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">set_parent</a> (void * parent, void *(* cleanup)(void *)) const noexcept</td></tr>
+<tr class="memdesc:aa7d281de451d5f47923f4ff1c5b7f2c9"><td class="mdescLeft"> </td><td class="mdescRight">Sets the parent of this slot. <a href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">More...</a><br /></td></tr>
+<tr class="separator:aa7d281de451d5f47923f4ff1c5b7f2c9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a25ad0bd4d2cea4dbfcd09f7d393d266d"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:a25ad0bd4d2cea4dbfcd09f7d393d266d"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state. <a href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">More...</a><br /></td></tr>
+<tr class="separator:a25ad0bd4d2cea4dbfcd09f7d393d266d"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:a9dc4958860c0f8300b461a743b7f2a2b"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">blocked_</a></td></tr>
+<tr class="memdesc:a9dc4958860c0f8300b461a743b7f2a2b"><td class="mdescLeft"> </td><td class="mdescRight">Indicates whether the slot is blocked. <a href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">More...</a><br /></td></tr>
+<tr class="separator:a9dc4958860c0f8300b461a743b7f2a2b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa482f7dfc73c6950abde0fd51b3125b5"><td class="memItemLeft" align="right" valign="top">rep_type * </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">rep_</a></td></tr>
+<tr class="memdesc:aa482f7dfc73c6950abde0fd51b3125b5"><td class="mdescLeft"> </td><td class="mdescRight">Typed slot_rep object that contains a functor. <a href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">More...</a><br /></td></tr>
+<tr class="separator:aa482f7dfc73c6950abde0fd51b3125b5"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><p>Base type for slots. </p>
+<p><a class="el" href="classsigc_1_1slot__base.html" title="Base type for slots.">slot_base</a> integrates most of the interface of the derived <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> templates. slots can be connected to signals, be disconnected at some later point (<a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857" title="Disconnects the slot.">disconnect()</a>) and temporarily be blocked (<a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9" title="Sets the blocking state.">block()</a>, <a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d" title="Unsets the blocking state.">unblock()</a>). The validity of a slot can be tested with <a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef" title="Returns whether the slot is invalid.">empty()</a>.</p>
+<p>The internal representation of a sigc::internal::slot_rep derived type is built from <a class="el" href="classsigc_1_1slot__base.html" title="Base type for slots.">slot_base</a>'s derivations. <a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9" title="Sets the parent of this slot.">set_parent()</a> is used to register a notification callback that is executed when the slot gets invalid. <a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694" title="Add a callback that is executed (notified) when the slot is detroyed.">add_destroy_notify_callback()</a> is used by connection objects to add a notification callback that is executed on destruction. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a7e1a0c2fe43a42187810e8997abeb341"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7e1a0c2fe43a42187810e8997abeb341">◆ </a></span>func_destroy_notify</h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">trackable::func_destroy_notify</a> <a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">sigc::slot_base::func_destroy_notify</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a182d5db71ef371838c73bcf1c135cd9a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a182d5db71ef371838c73bcf1c135cd9a">◆ </a></span>slot_base() <span class="overload">[1/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">sigc::slot_base::slot_base </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">noexcept</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an empty slot. </p>
+
+</div>
+</div>
+<a id="a5fbc2bf38a0d9ebcbe13d578d2b3d5a1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">◆ </a></span>slot_base() <span class="overload">[2/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">sigc::slot_base::slot_base </td>
+ <td>(</td>
+ <td class="paramtype">rep_type * </td>
+ <td class="paramname"><em>rep</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">explicit</span><span class="mlabel">noexcept</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a slot from an existing slot_rep object. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">rep</td><td>The slot_rep object this slot should contain. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="aadcbb54832b5207bddf89ac5433b531a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aadcbb54832b5207bddf89ac5433b531a">◆ </a></span>slot_base() <span class="overload">[3/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname">sigc::slot_base::slot_base </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, copying an existing one. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="ad1fee67a5885e424c275ad0f48fc81b1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad1fee67a5885e424c275ad0f48fc81b1">◆ </a></span>slot_base() <span class="overload">[4/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname">sigc::slot_base::slot_base </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+<p>Constructs a slot, moving an existing one. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The existing slot to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a75c18c50860f63fb020fc2953576ea57"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a75c18c50860f63fb020fc2953576ea57">◆ </a></span>~slot_base()</h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname">sigc::slot_base::~slot_base </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a8e37cc8f4b57898a288680e59bea2694"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8e37cc8f4b57898a288680e59bea2694">◆ </a></span>add_destroy_notify_callback()</h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname">void sigc::slot_base::add_destroy_notify_callback </td>
+ <td>(</td>
+ <td class="paramtype">void * </td>
+ <td class="paramname"><em>data</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">func_destroy_notify</a> </td>
+ <td class="paramname"><em>func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+<p>Add a callback that is executed (notified) when the slot is detroyed. </p>
+<p>This function is used internally by connection objects. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">data</td><td>Passed into func upon notification. </td></tr>
+ <tr><td class="paramname">func</td><td>Callback executed upon destruction of the object. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a657a8473164c963a5ca4828c88121bb9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a657a8473164c963a5ca4828c88121bb9">◆ </a></span>block()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">bool sigc::slot_base::block </td>
+ <td>(</td>
+ <td class="paramtype">bool </td>
+ <td class="paramname"><em>should_block</em> = <code>true</code></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">noexcept</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Sets the blocking state. </p>
+<p>If <em>should_block</em> is <code>true</code> then the blocking state is set. Subsequent calls to <a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d" title="Invoke the contained functor unless slot is in blocking state.">slot::operator()()</a> don't invoke the functor contained by this slot until <a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d" title="Unsets the blocking state.">unblock()</a> or <a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9" title="Sets the blocking state.">block()</a> with <em>should_block</em> = <code>false</code> is called. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">should_block</td><td>Indicates whether the blocking state should be set or unset. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>true</code> if the slot was in blocking state before. </dd></dl>
+
+</div>
+</div>
+<a id="a2f266b6147c4a6bbc5b68994d2dc1517"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2f266b6147c4a6bbc5b68994d2dc1517">◆ </a></span>blocked()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">bool sigc::slot_base::blocked </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">noexcept</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Returns whether the slot is blocked. </p>
+<dl class="section return"><dt>Returns</dt><dd><code>true</code> if the slot is blocked. </dd></dl>
+
+</div>
+</div>
+<a id="a4042d221f7f07a7394d2eb0f14db2857"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4042d221f7f07a7394d2eb0f14db2857">◆ </a></span>disconnect()</h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname">void sigc::slot_base::disconnect </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+<p>Disconnects the slot. </p>
+<p>Invalidates the slot and notifies the parent. </p>
+
+</div>
+</div>
+<a id="ae6ac6ca962a1f6a7506d0817165b5cef"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae6ac6ca962a1f6a7506d0817165b5cef">◆ </a></span>empty()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">bool sigc::slot_base::empty </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">noexcept</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Returns whether the slot is invalid. </p>
+<dl class="section return"><dt>Returns</dt><dd><code>true</code> if the slot is invalid (empty). </dd></dl>
+
+</div>
+</div>
+<a id="a90d4d7d6037973a94d7dfd7ba9a5feb9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a90d4d7d6037973a94d7dfd7ba9a5feb9">◆ </a></span>operator bool()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">sigc::slot_base::operator bool </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">explicit</span><span class="mlabel">noexcept</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Tests whether a slot is null, because the default constructor was used. </p>
+<p>Test a slot for null like so: </p><div class="fragment"><div class="line"><span class="keywordflow">if</span>(slot)</div>
+<div class="line"> do_something()</div>
+</div><!-- fragment -->
+</div>
+</div>
+<a id="a19522528264f1646f8ed982b0042ffad"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a19522528264f1646f8ed982b0042ffad">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a>& sigc::slot_base::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a copy from another slot. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to make a copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+<a id="a64e36f28ee61a94c0496fe76f6b3e813"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a64e36f28ee61a94c0496fe76f6b3e813">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a>& sigc::slot_base::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+<p>Overrides this slot, making a move from another slot. </p>
+<p>If <code>src</code> is connected to a parent (e.g. a signal), it is copied, not moved. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">src</td><td>The slot from which to move or copy. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>this</code>. </dd></dl>
+
+</div>
+</div>
+<a id="a69c55dedaa35626f288754d55b3da66c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a69c55dedaa35626f288754d55b3da66c">◆ </a></span>remove_destroy_notify_callback()</h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname">void sigc::slot_base::remove_destroy_notify_callback </td>
+ <td>(</td>
+ <td class="paramtype">void * </td>
+ <td class="paramname"><em>data</em></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+<p>Remove a callback previously installed with <a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694" title="Add a callback that is executed (notified) when the slot is detroyed.">add_destroy_notify_callback()</a>. </p>
+<p>The callback is not executed. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">data</td><td>Parameter passed into previous call to <a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694" title="Add a callback that is executed (notified) when the slot is detroyed.">add_destroy_notify_callback()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="aa7d281de451d5f47923f4ff1c5b7f2c9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa7d281de451d5f47923f4ff1c5b7f2c9">◆ </a></span>set_parent()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">void sigc::slot_base::set_parent </td>
+ <td>(</td>
+ <td class="paramtype">void * </td>
+ <td class="paramname"><em>parent</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">void *(*)(void *) </td>
+ <td class="paramname"><em>cleanup</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">noexcept</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Sets the parent of this slot. </p>
+<p>This function is used by signals to register a notification callback. This notification callback is executed when the slot becomes invalid because of some referred object dying. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">parent</td><td>The new parent. </td></tr>
+ <tr><td class="paramname">cleanup</td><td>The notification callback. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a25ad0bd4d2cea4dbfcd09f7d393d266d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a25ad0bd4d2cea4dbfcd09f7d393d266d">◆ </a></span>unblock()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">bool sigc::slot_base::unblock </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">noexcept</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Unsets the blocking state. </p>
+<dl class="section return"><dt>Returns</dt><dd><code>true</code> if the slot was in blocking state before. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a9dc4958860c0f8300b461a743b7f2a2b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9dc4958860c0f8300b461a743b7f2a2b">◆ </a></span>blocked_</h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname">bool sigc::slot_base::blocked_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+<p>Indicates whether the slot is blocked. </p>
+
+</div>
+</div>
+<a id="aa482f7dfc73c6950abde0fd51b3125b5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa482f7dfc73c6950abde0fd51b3125b5">◆ </a></span>rep_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">rep_type* sigc::slot_base::rep_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">mutable</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Typed slot_rep object that contains a functor. </p>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::slot_base" name="sigc::slot_base">
+<area shape="rect" id="node1" title="Base type for slots." alt="" coords="193,389,312,415"/>
+<area shape="rect" id="node3" href="$classsigc_1_1slot7.html" title=" " alt="" coords="374,23,535,79"/>
+<area shape="rect" id="node5" href="$classsigc_1_1slot0.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="369,126,541,153"/>
+<area shape="rect" id="node7" href="$classsigc_1_1slot1.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="374,195,535,236"/>
+<area shape="rect" id="node9" href="$classsigc_1_1slot2.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="374,272,535,313"/>
+<area shape="rect" id="node11" href="$classsigc_1_1slot3.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="360,344,549,385"/>
+<area shape="rect" id="node13" href="$classsigc_1_1slot4.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="365,410,544,466"/>
+<area shape="rect" id="node15" href="$classsigc_1_1slot5.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="365,490,544,546"/>
+<area shape="rect" id="node17" href="$classsigc_1_1slot6.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="360,570,549,626"/>
+<area shape="rect" id="node19" href="$classsigc_1_1slot7.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="365,651,544,721"/>
+<area shape="rect" id="node20" href="$classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="380,745,529,787"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,389,145,415"/>
+<area shape="rect" id="node4" href="$classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates." alt="" coords="615,5,793,76"/>
+<area shape="rect" id="node6" href="$classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot0 template." alt="" coords="627,101,781,157"/>
+<area shape="rect" id="node8" href="$classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot1 template." alt="" coords="627,181,781,237"/>
+<area shape="rect" id="node10" href="$classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot2 template." alt="" coords="627,261,781,317"/>
+<area shape="rect" id="node12" href="$classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot3 template." alt="" coords="615,341,793,397"/>
+<area shape="rect" id="node14" href="$classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot4 template." alt="" coords="615,421,793,477"/>
+<area shape="rect" id="node16" href="$classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot5 template." alt="" coords="611,501,797,557"/>
+<area shape="rect" id="node18" href="$classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot6 template." alt="" coords="597,581,811,637"/>
+</map>
--- /dev/null
+fef645bee8875718edc0a15751653b2b
\ No newline at end of file
--- /dev/null
+<map id="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >" name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >">
+<area shape="rect" id="node1" title="Convenience wrapper for the numbered sigc::slot# templates." alt="" coords="5,259,184,329"/>
+<area shape="rect" id="node2" href="$classsigc_1_1slot7.html" title=" " alt="" coords="14,155,175,211"/>
+<area shape="rect" id="node3" href="$classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="35,80,154,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="25,5,165,32"/>
+</map>
--- /dev/null
+d3cc0d13c8ec8cac03eaa859d89b38b2
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1track__obj__functor1.html">track_obj_functor1</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::track_obj_functor1< T_functor, T_obj1 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#ab36332c8e8815546730b525f739d9ebf">adaptor_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a>(const T_functor & _A_functor)</td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a3a4b2ca8d1c83356dcf7d5ba93051986">operator()</a>()</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a3da19bfd10f0b9f84ae83b06f8211ae6">operator()</a>(T_arg1 _A_arg1)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a933452a80a7c98d4865624d2f60b2527">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#abb1206272535caa14e1109d198ab0b1f">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a94fba99da25a041007a4f2f07b19c784">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a8bf05204e43be21b027a79ffb7aed13e">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a610d215dd82c2a3112aef9bb29edd856">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a758ed994bc823ce29001873838384ac0">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6, T_arg7 _A_arg7)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a17ad87a124cb6fafc37a2d573d47f222">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a1bcc00d3b665af8f40fa18936fab5304">track_obj_functor1</a>(const T_functor & _A_func, const T_obj1 & _A_obj1)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::track_obj_functor1< T_functor, T_obj1 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1track__obj__functor1.html">track_obj_functor1</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1track__obj__functor1-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::track_obj_functor1< T_functor, T_obj1 > Class Template Reference<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a> » <a class="el" href="group__track__obj.html">track_obj()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object.">track_obj_functor1</a> wraps a functor and stores a reference to a trackable object.
+ <a href="classsigc_1_1track__obj__functor1.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/track_obj.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::track_obj_functor1< T_functor, T_obj1 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1track__obj__functor1__inherit__graph.png" border="0" usemap="#asigc_1_1track__obj__functor1_3_01T__functor_00_01T__obj1_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1track__obj__functor1_3_01T__functor_00_01T__obj1_01_4_inherit__map" id="asigc_1_1track__obj__functor1_3_01T__functor_00_01T__obj1_01_4_inherit__map">
+<area shape="rect" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object." alt="" coords="624,199,801,240"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor2.html" title="track_obj_functor2 wraps a functor and stores 2 references to trackable objects." alt="" coords="855,5,1069,47"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor3.html" title="track_obj_functor3 wraps a functor and stores 3 references to trackable objects." alt="" coords="873,71,1051,127"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor4.html" title="track_obj_functor4 wraps a functor and stores 4 references to trackable objects." alt="" coords="873,151,1051,207"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor5.html" title="track_obj_functor5 wraps a functor and stores 5 references to trackable objects." alt="" coords="849,231,1075,287"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor6.html" title="track_obj_functor6 wraps a functor and stores 6 references to trackable objects." alt="" coords="873,312,1051,383"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor7.html" title="track_obj_functor7 wraps a functor and stores 7 references to trackable objects." alt="" coords="873,407,1051,477"/>
+<area shape="rect" href="structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="385,206,576,233"/>
+<area shape="rect" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="193,206,337,233"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,206,145,233"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:ab36332c8e8815546730b525f739d9ebf"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adapts.html">adapts</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#ab36332c8e8815546730b525f739d9ebf">adaptor_type</a></td></tr>
+<tr class="separator:ab36332c8e8815546730b525f739d9ebf"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17ad87a124cb6fafc37a2d573d47f222"><td class="memItemLeft" align="right" valign="top">typedef adaptor_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a17ad87a124cb6fafc37a2d573d47f222">result_type</a></td></tr>
+<tr class="separator:a17ad87a124cb6fafc37a2d573d47f222"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td></tr>
+<tr class="separator:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td></tr>
+<tr class="separator:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a1bcc00d3b665af8f40fa18936fab5304"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a1bcc00d3b665af8f40fa18936fab5304">track_obj_functor1</a> (const T_functor & _A_func, const T_obj1 & _A_obj1)</td></tr>
+<tr class="memdesc:a1bcc00d3b665af8f40fa18936fab5304"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object.">track_obj_functor1</a> object that wraps the passed functor and stores a reference to the passed trackable object. <a href="classsigc_1_1track__obj__functor1.html#a1bcc00d3b665af8f40fa18936fab5304">More...</a><br /></td></tr>
+<tr class="separator:a1bcc00d3b665af8f40fa18936fab5304"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3a4b2ca8d1c83356dcf7d5ba93051986"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a3a4b2ca8d1c83356dcf7d5ba93051986">operator()</a> ()</td></tr>
+<tr class="memdesc:a3a4b2ca8d1c83356dcf7d5ba93051986"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor. <a href="classsigc_1_1track__obj__functor1.html#a3a4b2ca8d1c83356dcf7d5ba93051986">More...</a><br /></td></tr>
+<tr class="separator:a3a4b2ca8d1c83356dcf7d5ba93051986"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3da19bfd10f0b9f84ae83b06f8211ae6"><td class="memTemplParams" colspan="2">template<typename T_arg1 > </td></tr>
+<tr class="memitem:a3da19bfd10f0b9f84ae83b06f8211ae6"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a3da19bfd10f0b9f84ae83b06f8211ae6">operator()</a> (T_arg1 _A_arg1)</td></tr>
+<tr class="memdesc:a3da19bfd10f0b9f84ae83b06f8211ae6"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a3da19bfd10f0b9f84ae83b06f8211ae6">More...</a><br /></td></tr>
+<tr class="separator:a3da19bfd10f0b9f84ae83b06f8211ae6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a933452a80a7c98d4865624d2f60b2527"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 > </td></tr>
+<tr class="memitem:a933452a80a7c98d4865624d2f60b2527"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a933452a80a7c98d4865624d2f60b2527">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2)</td></tr>
+<tr class="memdesc:a933452a80a7c98d4865624d2f60b2527"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a933452a80a7c98d4865624d2f60b2527">More...</a><br /></td></tr>
+<tr class="separator:a933452a80a7c98d4865624d2f60b2527"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abb1206272535caa14e1109d198ab0b1f"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 > </td></tr>
+<tr class="memitem:abb1206272535caa14e1109d198ab0b1f"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#abb1206272535caa14e1109d198ab0b1f">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)</td></tr>
+<tr class="memdesc:abb1206272535caa14e1109d198ab0b1f"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#abb1206272535caa14e1109d198ab0b1f">More...</a><br /></td></tr>
+<tr class="separator:abb1206272535caa14e1109d198ab0b1f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a94fba99da25a041007a4f2f07b19c784"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 > </td></tr>
+<tr class="memitem:a94fba99da25a041007a4f2f07b19c784"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a94fba99da25a041007a4f2f07b19c784">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)</td></tr>
+<tr class="memdesc:a94fba99da25a041007a4f2f07b19c784"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a94fba99da25a041007a4f2f07b19c784">More...</a><br /></td></tr>
+<tr class="separator:a94fba99da25a041007a4f2f07b19c784"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8bf05204e43be21b027a79ffb7aed13e"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 , typename T_arg5 > </td></tr>
+<tr class="memitem:a8bf05204e43be21b027a79ffb7aed13e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a8bf05204e43be21b027a79ffb7aed13e">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)</td></tr>
+<tr class="memdesc:a8bf05204e43be21b027a79ffb7aed13e"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a8bf05204e43be21b027a79ffb7aed13e">More...</a><br /></td></tr>
+<tr class="separator:a8bf05204e43be21b027a79ffb7aed13e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a610d215dd82c2a3112aef9bb29edd856"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 , typename T_arg5 , typename T_arg6 > </td></tr>
+<tr class="memitem:a610d215dd82c2a3112aef9bb29edd856"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a610d215dd82c2a3112aef9bb29edd856">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)</td></tr>
+<tr class="memdesc:a610d215dd82c2a3112aef9bb29edd856"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a610d215dd82c2a3112aef9bb29edd856">More...</a><br /></td></tr>
+<tr class="separator:a610d215dd82c2a3112aef9bb29edd856"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a758ed994bc823ce29001873838384ac0"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 , typename T_arg5 , typename T_arg6 , typename T_arg7 > </td></tr>
+<tr class="memitem:a758ed994bc823ce29001873838384ac0"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a758ed994bc823ce29001873838384ac0">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6, T_arg7 _A_arg7)</td></tr>
+<tr class="memdesc:a758ed994bc823ce29001873838384ac0"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a758ed994bc823ce29001873838384ac0">More...</a><br /></td></tr>
+<tr class="separator:a758ed994bc823ce29001873838384ac0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a> (const T_functor & _A_functor)</td></tr>
+<tr class="memdesc:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an adaptor that wraps the passed functor. <a href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">More...</a><br /></td></tr>
+<tr class="separator:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_attribs_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td></tr>
+<tr class="memdesc:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that is invoked from operator()(). <a href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">More...</a><br /></td></tr>
+<tr class="separator:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<typename T_functor, typename T_obj1><br />
+class sigc::track_obj_functor1< T_functor, T_obj1 ></h3>
+
+<p><a class="el" href="classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object.">track_obj_functor1</a> wraps a functor and stores a reference to a trackable object. </p>
+<p>Use the convenience function <a class="el" href="group__track__obj.html#ga8fd1ab36d123ff83dd4cd8dc58bb28e2" title="Creates an adaptor of type sigc::track_obj_functor1 which wraps a functor.">track_obj()</a> to create an instance of <a class="el" href="classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object.">track_obj_functor1</a>.</p>
+<dl class="tparams"><dt>Template Parameters</dt><dd>
+ <table class="tparams">
+ <tr><td class="paramname">T_functor</td><td>The type of functor to wrap. </td></tr>
+ <tr><td class="paramname">T_obj1</td><td>The type of a trackable object.</td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="since_2_4"><dt><b><a class="el" href="since_2_4.html#_since_2_4000002">Since libsigc++ 2.4:</a></b></dt><dd></dd></dl>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="ab36332c8e8815546730b525f739d9ebf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab36332c8e8815546730b525f739d9ebf">◆ </a></span>adaptor_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_functor , typename T_obj1 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1adapts.html">adapts</a><T_functor>::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> <a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1</a>< T_functor, T_obj1 >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a17ad87a124cb6fafc37a2d573d47f222"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a17ad87a124cb6fafc37a2d573d47f222">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_functor , typename T_obj1 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef adaptor_type::result_type <a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1</a>< T_functor, T_obj1 >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a1bcc00d3b665af8f40fa18936fab5304"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1bcc00d3b665af8f40fa18936fab5304">◆ </a></span>track_obj_functor1()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_functor , typename T_obj1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1</a>< T_functor, T_obj1 >::<a class="el" href="classsigc_1_1track__obj__functor1.html">track_obj_functor1</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj1 & </td>
+ <td class="paramname"><em>_A_obj1</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object.">track_obj_functor1</a> object that wraps the passed functor and stores a reference to the passed trackable object. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Functor. </td></tr>
+ <tr><td class="paramname">_A_obj1</td><td>Trackable object. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a3a4b2ca8d1c83356dcf7d5ba93051986"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3a4b2ca8d1c83356dcf7d5ba93051986">◆ </a></span>operator()() <span class="overload">[1/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_functor , typename T_obj1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> <a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1</a>< T_functor, T_obj1 >::operator() </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor. </p>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a3da19bfd10f0b9f84ae83b06f8211ae6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3da19bfd10f0b9f84ae83b06f8211ae6">◆ </a></span>operator()() <span class="overload">[2/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_functor , typename T_obj1 > </div>
+<div class="memtemplate">
+template <typename T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1>::type <a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1</a>< T_functor, T_obj1 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_arg1</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_arg1</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a933452a80a7c98d4865624d2f60b2527"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a933452a80a7c98d4865624d2f60b2527">◆ </a></span>operator()() <span class="overload">[3/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_functor , typename T_obj1 > </div>
+<div class="memtemplate">
+template <typename T_arg1 , typename T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2>::type <a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1</a>< T_functor, T_obj1 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_arg1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_arg2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_arg1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg2</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="abb1206272535caa14e1109d198ab0b1f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abb1206272535caa14e1109d198ab0b1f">◆ </a></span>operator()() <span class="overload">[4/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_functor , typename T_obj1 > </div>
+<div class="memtemplate">
+template <typename T_arg1 , typename T_arg2 , typename T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3>::type <a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1</a>< T_functor, T_obj1 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_arg1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_arg2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_arg3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_arg1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg3</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a94fba99da25a041007a4f2f07b19c784"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a94fba99da25a041007a4f2f07b19c784">◆ </a></span>operator()() <span class="overload">[5/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_functor , typename T_obj1 > </div>
+<div class="memtemplate">
+template <typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4>::type <a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1</a>< T_functor, T_obj1 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_arg1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_arg2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_arg3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_arg4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_arg1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg4</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a8bf05204e43be21b027a79ffb7aed13e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8bf05204e43be21b027a79ffb7aed13e">◆ </a></span>operator()() <span class="overload">[6/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_functor , typename T_obj1 > </div>
+<div class="memtemplate">
+template <typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 , typename T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type <a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1</a>< T_functor, T_obj1 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_arg1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_arg2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_arg3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_arg4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_arg5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_arg1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg4</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg5</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a610d215dd82c2a3112aef9bb29edd856"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a610d215dd82c2a3112aef9bb29edd856">◆ </a></span>operator()() <span class="overload">[7/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_functor , typename T_obj1 > </div>
+<div class="memtemplate">
+template <typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 , typename T_arg5 , typename T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type <a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1</a>< T_functor, T_obj1 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_arg1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_arg2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_arg3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_arg4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_arg5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg6 </td>
+ <td class="paramname"><em>_A_arg6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_arg1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg4</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg5</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg6</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a758ed994bc823ce29001873838384ac0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a758ed994bc823ce29001873838384ac0">◆ </a></span>operator()() <span class="overload">[8/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_functor , typename T_obj1 > </div>
+<div class="memtemplate">
+template <typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 , typename T_arg5 , typename T_arg6 , typename T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type <a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1</a>< T_functor, T_obj1 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_arg1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_arg2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_arg3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_arg4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_arg5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg6 </td>
+ <td class="paramname"><em>_A_arg6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg7 </td>
+ <td class="paramname"><em>_A_arg7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_arg1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg4</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg5</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg6</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg7</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::track_obj_functor1< T_functor, T_obj1 >" name="sigc::track_obj_functor1< T_functor, T_obj1 >">
+<area shape="rect" id="node1" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object." alt="" coords="624,199,801,240"/>
+<area shape="rect" id="node5" href="$classsigc_1_1track__obj__functor2.html" title="track_obj_functor2 wraps a functor and stores 2 references to trackable objects." alt="" coords="855,5,1069,47"/>
+<area shape="rect" id="node6" href="$classsigc_1_1track__obj__functor3.html" title="track_obj_functor3 wraps a functor and stores 3 references to trackable objects." alt="" coords="873,71,1051,127"/>
+<area shape="rect" id="node7" href="$classsigc_1_1track__obj__functor4.html" title="track_obj_functor4 wraps a functor and stores 4 references to trackable objects." alt="" coords="873,151,1051,207"/>
+<area shape="rect" id="node8" href="$classsigc_1_1track__obj__functor5.html" title="track_obj_functor5 wraps a functor and stores 5 references to trackable objects." alt="" coords="849,231,1075,287"/>
+<area shape="rect" id="node9" href="$classsigc_1_1track__obj__functor6.html" title="track_obj_functor6 wraps a functor and stores 6 references to trackable objects." alt="" coords="873,312,1051,383"/>
+<area shape="rect" id="node10" href="$classsigc_1_1track__obj__functor7.html" title="track_obj_functor7 wraps a functor and stores 7 references to trackable objects." alt="" coords="873,407,1051,477"/>
+<area shape="rect" id="node2" href="$structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="385,206,576,233"/>
+<area shape="rect" id="node3" href="$structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="193,206,337,233"/>
+<area shape="rect" id="node4" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,206,145,233"/>
+</map>
--- /dev/null
+ea098ee669891d230efd9fb70a726529
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1track__obj__functor2.html">track_obj_functor2</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::track_obj_functor2< T_functor, T_obj1, T_obj2 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1track__obj__functor2.html">sigc::track_obj_functor2< T_functor, T_obj1, T_obj2 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#ab36332c8e8815546730b525f739d9ebf">adaptor_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a>(const T_functor & _A_functor)</td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a3a4b2ca8d1c83356dcf7d5ba93051986">operator()</a>()</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a3da19bfd10f0b9f84ae83b06f8211ae6">operator()</a>(T_arg1 _A_arg1)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a933452a80a7c98d4865624d2f60b2527">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#abb1206272535caa14e1109d198ab0b1f">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a94fba99da25a041007a4f2f07b19c784">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a8bf05204e43be21b027a79ffb7aed13e">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a610d215dd82c2a3112aef9bb29edd856">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a758ed994bc823ce29001873838384ac0">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6, T_arg7 _A_arg7)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a17ad87a124cb6fafc37a2d573d47f222">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a1bcc00d3b665af8f40fa18936fab5304">track_obj_functor1</a>(const T_functor & _A_func, const T_obj1 & _A_obj1)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor2.html#ae12b4c85e92a265c011fccf090fa6947">track_obj_functor2</a>(const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor2.html">sigc::track_obj_functor2< T_functor, T_obj1, T_obj2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::track_obj_functor2< T_functor, T_obj1, T_obj2 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1track__obj__functor2.html">track_obj_functor2</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1track__obj__functor2-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::track_obj_functor2< T_functor, T_obj1, T_obj2 > Class Template Reference<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a> » <a class="el" href="group__track__obj.html">track_obj()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1track__obj__functor2.html" title="track_obj_functor2 wraps a functor and stores 2 references to trackable objects.">track_obj_functor2</a> wraps a functor and stores 2 references to trackable objects.
+ <a href="classsigc_1_1track__obj__functor2.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/track_obj.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::track_obj_functor2< T_functor, T_obj1, T_obj2 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1track__obj__functor2__inherit__graph.png" border="0" usemap="#asigc_1_1track__obj__functor2_3_01T__functor_00_01T__obj1_00_01T__obj2_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1track__obj__functor2_3_01T__functor_00_01T__obj1_00_01T__obj2_01_4_inherit__map" id="asigc_1_1track__obj__functor2_3_01T__functor_00_01T__obj1_00_01T__obj2_01_4_inherit__map">
+<area shape="rect" title="track_obj_functor2 wraps a functor and stores 2 references to trackable objects." alt="" coords="5,319,220,360"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object." alt="" coords="24,229,201,271"/>
+<area shape="rect" href="structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="17,155,208,181"/>
+<area shape="rect" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="41,80,185,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="43,5,183,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:ae12b4c85e92a265c011fccf090fa6947"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor2.html#ae12b4c85e92a265c011fccf090fa6947">track_obj_functor2</a> (const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2)</td></tr>
+<tr class="memdesc:ae12b4c85e92a265c011fccf090fa6947"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1track__obj__functor2.html" title="track_obj_functor2 wraps a functor and stores 2 references to trackable objects.">track_obj_functor2</a> object that wraps the passed functor and stores references to the passed trackable objects. <a href="classsigc_1_1track__obj__functor2.html#ae12b4c85e92a265c011fccf090fa6947">More...</a><br /></td></tr>
+<tr class="separator:ae12b4c85e92a265c011fccf090fa6947"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1track__obj__functor1"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1track__obj__functor1')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td></tr>
+<tr class="memitem:a1bcc00d3b665af8f40fa18936fab5304 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a1bcc00d3b665af8f40fa18936fab5304">track_obj_functor1</a> (const T_functor & _A_func, const T_obj1 & _A_obj1)</td></tr>
+<tr class="memdesc:a1bcc00d3b665af8f40fa18936fab5304 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object.">track_obj_functor1</a> object that wraps the passed functor and stores a reference to the passed trackable object. <a href="classsigc_1_1track__obj__functor1.html#a1bcc00d3b665af8f40fa18936fab5304">More...</a><br /></td></tr>
+<tr class="separator:a1bcc00d3b665af8f40fa18936fab5304 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3a4b2ca8d1c83356dcf7d5ba93051986 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a3a4b2ca8d1c83356dcf7d5ba93051986">operator()</a> ()</td></tr>
+<tr class="memdesc:a3a4b2ca8d1c83356dcf7d5ba93051986 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor. <a href="classsigc_1_1track__obj__functor1.html#a3a4b2ca8d1c83356dcf7d5ba93051986">More...</a><br /></td></tr>
+<tr class="separator:a3a4b2ca8d1c83356dcf7d5ba93051986 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3da19bfd10f0b9f84ae83b06f8211ae6 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 > </td></tr>
+<tr class="memitem:a3da19bfd10f0b9f84ae83b06f8211ae6 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a3da19bfd10f0b9f84ae83b06f8211ae6">operator()</a> (T_arg1 _A_arg1)</td></tr>
+<tr class="memdesc:a3da19bfd10f0b9f84ae83b06f8211ae6 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a3da19bfd10f0b9f84ae83b06f8211ae6">More...</a><br /></td></tr>
+<tr class="separator:a3da19bfd10f0b9f84ae83b06f8211ae6 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a933452a80a7c98d4865624d2f60b2527 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 > </td></tr>
+<tr class="memitem:a933452a80a7c98d4865624d2f60b2527 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a933452a80a7c98d4865624d2f60b2527">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2)</td></tr>
+<tr class="memdesc:a933452a80a7c98d4865624d2f60b2527 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a933452a80a7c98d4865624d2f60b2527">More...</a><br /></td></tr>
+<tr class="separator:a933452a80a7c98d4865624d2f60b2527 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abb1206272535caa14e1109d198ab0b1f inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 > </td></tr>
+<tr class="memitem:abb1206272535caa14e1109d198ab0b1f inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#abb1206272535caa14e1109d198ab0b1f">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)</td></tr>
+<tr class="memdesc:abb1206272535caa14e1109d198ab0b1f inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#abb1206272535caa14e1109d198ab0b1f">More...</a><br /></td></tr>
+<tr class="separator:abb1206272535caa14e1109d198ab0b1f inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a94fba99da25a041007a4f2f07b19c784 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 > </td></tr>
+<tr class="memitem:a94fba99da25a041007a4f2f07b19c784 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a94fba99da25a041007a4f2f07b19c784">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)</td></tr>
+<tr class="memdesc:a94fba99da25a041007a4f2f07b19c784 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a94fba99da25a041007a4f2f07b19c784">More...</a><br /></td></tr>
+<tr class="separator:a94fba99da25a041007a4f2f07b19c784 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8bf05204e43be21b027a79ffb7aed13e inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 , typename T_arg5 > </td></tr>
+<tr class="memitem:a8bf05204e43be21b027a79ffb7aed13e inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a8bf05204e43be21b027a79ffb7aed13e">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)</td></tr>
+<tr class="memdesc:a8bf05204e43be21b027a79ffb7aed13e inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a8bf05204e43be21b027a79ffb7aed13e">More...</a><br /></td></tr>
+<tr class="separator:a8bf05204e43be21b027a79ffb7aed13e inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a610d215dd82c2a3112aef9bb29edd856 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 , typename T_arg5 , typename T_arg6 > </td></tr>
+<tr class="memitem:a610d215dd82c2a3112aef9bb29edd856 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a610d215dd82c2a3112aef9bb29edd856">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)</td></tr>
+<tr class="memdesc:a610d215dd82c2a3112aef9bb29edd856 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a610d215dd82c2a3112aef9bb29edd856">More...</a><br /></td></tr>
+<tr class="separator:a610d215dd82c2a3112aef9bb29edd856 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a758ed994bc823ce29001873838384ac0 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 , typename T_arg5 , typename T_arg6 , typename T_arg7 > </td></tr>
+<tr class="memitem:a758ed994bc823ce29001873838384ac0 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a758ed994bc823ce29001873838384ac0">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6, T_arg7 _A_arg7)</td></tr>
+<tr class="memdesc:a758ed994bc823ce29001873838384ac0 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a758ed994bc823ce29001873838384ac0">More...</a><br /></td></tr>
+<tr class="separator:a758ed994bc823ce29001873838384ac0 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a> (const T_functor & _A_functor)</td></tr>
+<tr class="memdesc:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an adaptor that wraps the passed functor. <a href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">More...</a><br /></td></tr>
+<tr class="separator:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1track__obj__functor1"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1track__obj__functor1')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td></tr>
+<tr class="memitem:ab36332c8e8815546730b525f739d9ebf inherit pub_types_classsigc_1_1track__obj__functor1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adapts.html">adapts</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#ab36332c8e8815546730b525f739d9ebf">adaptor_type</a></td></tr>
+<tr class="separator:ab36332c8e8815546730b525f739d9ebf inherit pub_types_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17ad87a124cb6fafc37a2d573d47f222 inherit pub_types_classsigc_1_1track__obj__functor1"><td class="memItemLeft" align="right" valign="top">typedef adaptor_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a17ad87a124cb6fafc37a2d573d47f222">result_type</a></td></tr>
+<tr class="separator:a17ad87a124cb6fafc37a2d573d47f222 inherit pub_types_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td></tr>
+<tr class="separator:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td></tr>
+<tr class="separator:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_attribs_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td></tr>
+<tr class="memdesc:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that is invoked from operator()(). <a href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">More...</a><br /></td></tr>
+<tr class="separator:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<typename T_functor, typename T_obj1, typename T_obj2><br />
+class sigc::track_obj_functor2< T_functor, T_obj1, T_obj2 ></h3>
+
+<p><a class="el" href="classsigc_1_1track__obj__functor2.html" title="track_obj_functor2 wraps a functor and stores 2 references to trackable objects.">track_obj_functor2</a> wraps a functor and stores 2 references to trackable objects. </p>
+<p>Use the convenience function <a class="el" href="group__track__obj.html#ga8fd1ab36d123ff83dd4cd8dc58bb28e2" title="Creates an adaptor of type sigc::track_obj_functor1 which wraps a functor.">track_obj()</a> to create an instance of <a class="el" href="classsigc_1_1track__obj__functor2.html" title="track_obj_functor2 wraps a functor and stores 2 references to trackable objects.">track_obj_functor2</a>.</p>
+<dl class="tparams"><dt>Template Parameters</dt><dd>
+ <table class="tparams">
+ <tr><td class="paramname">T_functor</td><td>The type of functor to wrap. </td></tr>
+ <tr><td class="paramname">T_obj1</td><td>The type of a trackable object. </td></tr>
+ <tr><td class="paramname">T_obj2</td><td>The type of a trackable object.</td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="since_2_4"><dt><b><a class="el" href="since_2_4.html#_since_2_4000003">Since libsigc++ 2.4:</a></b></dt><dd></dd></dl>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="ae12b4c85e92a265c011fccf090fa6947"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae12b4c85e92a265c011fccf090fa6947">◆ </a></span>track_obj_functor2()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_functor , typename T_obj1 , typename T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1track__obj__functor2.html">sigc::track_obj_functor2</a>< T_functor, T_obj1, T_obj2 >::<a class="el" href="classsigc_1_1track__obj__functor2.html">track_obj_functor2</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj1 & </td>
+ <td class="paramname"><em>_A_obj1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj2 & </td>
+ <td class="paramname"><em>_A_obj2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1track__obj__functor2.html" title="track_obj_functor2 wraps a functor and stores 2 references to trackable objects.">track_obj_functor2</a> object that wraps the passed functor and stores references to the passed trackable objects. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Functor. </td></tr>
+ <tr><td class="paramname">_A_obj1</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj2</td><td>Trackable object. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::track_obj_functor2< T_functor, T_obj1, T_obj2 >" name="sigc::track_obj_functor2< T_functor, T_obj1, T_obj2 >">
+<area shape="rect" id="node1" title="track_obj_functor2 wraps a functor and stores 2 references to trackable objects." alt="" coords="5,319,220,360"/>
+<area shape="rect" id="node2" href="$classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object." alt="" coords="24,229,201,271"/>
+<area shape="rect" id="node3" href="$structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="17,155,208,181"/>
+<area shape="rect" id="node4" href="$structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="41,80,185,107"/>
+<area shape="rect" id="node5" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="43,5,183,32"/>
+</map>
--- /dev/null
+8470a1800918b744b596256e6ca56075
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1track__obj__functor3.html">track_obj_functor3</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::track_obj_functor3< T_functor, T_obj1, T_obj2, T_obj3 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1track__obj__functor3.html">sigc::track_obj_functor3< T_functor, T_obj1, T_obj2, T_obj3 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#ab36332c8e8815546730b525f739d9ebf">adaptor_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a>(const T_functor & _A_functor)</td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a3a4b2ca8d1c83356dcf7d5ba93051986">operator()</a>()</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a3da19bfd10f0b9f84ae83b06f8211ae6">operator()</a>(T_arg1 _A_arg1)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a933452a80a7c98d4865624d2f60b2527">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#abb1206272535caa14e1109d198ab0b1f">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a94fba99da25a041007a4f2f07b19c784">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a8bf05204e43be21b027a79ffb7aed13e">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a610d215dd82c2a3112aef9bb29edd856">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a758ed994bc823ce29001873838384ac0">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6, T_arg7 _A_arg7)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a17ad87a124cb6fafc37a2d573d47f222">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a1bcc00d3b665af8f40fa18936fab5304">track_obj_functor1</a>(const T_functor & _A_func, const T_obj1 & _A_obj1)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor3.html#add83622dc2ad7cd561d2c59768eea45a">track_obj_functor3</a>(const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2, const T_obj3 & _A_obj3)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor3.html">sigc::track_obj_functor3< T_functor, T_obj1, T_obj2, T_obj3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::track_obj_functor3< T_functor, T_obj1, T_obj2, T_obj3 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1track__obj__functor3.html">track_obj_functor3</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1track__obj__functor3-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::track_obj_functor3< T_functor, T_obj1, T_obj2, T_obj3 > Class Template Reference<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a> » <a class="el" href="group__track__obj.html">track_obj()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1track__obj__functor3.html" title="track_obj_functor3 wraps a functor and stores 3 references to trackable objects.">track_obj_functor3</a> wraps a functor and stores 3 references to trackable objects.
+ <a href="classsigc_1_1track__obj__functor3.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/track_obj.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::track_obj_functor3< T_functor, T_obj1, T_obj2, T_obj3 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1track__obj__functor3__inherit__graph.png" border="0" usemap="#asigc_1_1track__obj__functor3_3_01T__functor_00_01T__obj1_00_01T__obj2_00_01T__obj3_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1track__obj__functor3_3_01T__functor_00_01T__obj1_00_01T__obj2_00_01T__obj3_01_4_inherit__map" id="asigc_1_1track__obj__functor3_3_01T__functor_00_01T__obj1_00_01T__obj2_00_01T__obj3_01_4_inherit__map">
+<area shape="rect" title="track_obj_functor3 wraps a functor and stores 3 references to trackable objects." alt="" coords="12,319,189,375"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object." alt="" coords="12,229,189,271"/>
+<area shape="rect" href="structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="5,155,196,181"/>
+<area shape="rect" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="29,80,173,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="31,5,171,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:add83622dc2ad7cd561d2c59768eea45a"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor3.html#add83622dc2ad7cd561d2c59768eea45a">track_obj_functor3</a> (const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2, const T_obj3 & _A_obj3)</td></tr>
+<tr class="memdesc:add83622dc2ad7cd561d2c59768eea45a"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1track__obj__functor3.html" title="track_obj_functor3 wraps a functor and stores 3 references to trackable objects.">track_obj_functor3</a> object that wraps the passed functor and stores references to the passed trackable objects. <a href="classsigc_1_1track__obj__functor3.html#add83622dc2ad7cd561d2c59768eea45a">More...</a><br /></td></tr>
+<tr class="separator:add83622dc2ad7cd561d2c59768eea45a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1track__obj__functor1"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1track__obj__functor1')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td></tr>
+<tr class="memitem:a1bcc00d3b665af8f40fa18936fab5304 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a1bcc00d3b665af8f40fa18936fab5304">track_obj_functor1</a> (const T_functor & _A_func, const T_obj1 & _A_obj1)</td></tr>
+<tr class="memdesc:a1bcc00d3b665af8f40fa18936fab5304 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object.">track_obj_functor1</a> object that wraps the passed functor and stores a reference to the passed trackable object. <a href="classsigc_1_1track__obj__functor1.html#a1bcc00d3b665af8f40fa18936fab5304">More...</a><br /></td></tr>
+<tr class="separator:a1bcc00d3b665af8f40fa18936fab5304 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3a4b2ca8d1c83356dcf7d5ba93051986 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a3a4b2ca8d1c83356dcf7d5ba93051986">operator()</a> ()</td></tr>
+<tr class="memdesc:a3a4b2ca8d1c83356dcf7d5ba93051986 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor. <a href="classsigc_1_1track__obj__functor1.html#a3a4b2ca8d1c83356dcf7d5ba93051986">More...</a><br /></td></tr>
+<tr class="separator:a3a4b2ca8d1c83356dcf7d5ba93051986 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3da19bfd10f0b9f84ae83b06f8211ae6 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 > </td></tr>
+<tr class="memitem:a3da19bfd10f0b9f84ae83b06f8211ae6 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a3da19bfd10f0b9f84ae83b06f8211ae6">operator()</a> (T_arg1 _A_arg1)</td></tr>
+<tr class="memdesc:a3da19bfd10f0b9f84ae83b06f8211ae6 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a3da19bfd10f0b9f84ae83b06f8211ae6">More...</a><br /></td></tr>
+<tr class="separator:a3da19bfd10f0b9f84ae83b06f8211ae6 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a933452a80a7c98d4865624d2f60b2527 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 > </td></tr>
+<tr class="memitem:a933452a80a7c98d4865624d2f60b2527 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a933452a80a7c98d4865624d2f60b2527">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2)</td></tr>
+<tr class="memdesc:a933452a80a7c98d4865624d2f60b2527 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a933452a80a7c98d4865624d2f60b2527">More...</a><br /></td></tr>
+<tr class="separator:a933452a80a7c98d4865624d2f60b2527 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abb1206272535caa14e1109d198ab0b1f inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 > </td></tr>
+<tr class="memitem:abb1206272535caa14e1109d198ab0b1f inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#abb1206272535caa14e1109d198ab0b1f">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)</td></tr>
+<tr class="memdesc:abb1206272535caa14e1109d198ab0b1f inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#abb1206272535caa14e1109d198ab0b1f">More...</a><br /></td></tr>
+<tr class="separator:abb1206272535caa14e1109d198ab0b1f inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a94fba99da25a041007a4f2f07b19c784 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 > </td></tr>
+<tr class="memitem:a94fba99da25a041007a4f2f07b19c784 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a94fba99da25a041007a4f2f07b19c784">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)</td></tr>
+<tr class="memdesc:a94fba99da25a041007a4f2f07b19c784 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a94fba99da25a041007a4f2f07b19c784">More...</a><br /></td></tr>
+<tr class="separator:a94fba99da25a041007a4f2f07b19c784 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8bf05204e43be21b027a79ffb7aed13e inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 , typename T_arg5 > </td></tr>
+<tr class="memitem:a8bf05204e43be21b027a79ffb7aed13e inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a8bf05204e43be21b027a79ffb7aed13e">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)</td></tr>
+<tr class="memdesc:a8bf05204e43be21b027a79ffb7aed13e inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a8bf05204e43be21b027a79ffb7aed13e">More...</a><br /></td></tr>
+<tr class="separator:a8bf05204e43be21b027a79ffb7aed13e inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a610d215dd82c2a3112aef9bb29edd856 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 , typename T_arg5 , typename T_arg6 > </td></tr>
+<tr class="memitem:a610d215dd82c2a3112aef9bb29edd856 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a610d215dd82c2a3112aef9bb29edd856">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)</td></tr>
+<tr class="memdesc:a610d215dd82c2a3112aef9bb29edd856 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a610d215dd82c2a3112aef9bb29edd856">More...</a><br /></td></tr>
+<tr class="separator:a610d215dd82c2a3112aef9bb29edd856 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a758ed994bc823ce29001873838384ac0 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 , typename T_arg5 , typename T_arg6 , typename T_arg7 > </td></tr>
+<tr class="memitem:a758ed994bc823ce29001873838384ac0 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a758ed994bc823ce29001873838384ac0">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6, T_arg7 _A_arg7)</td></tr>
+<tr class="memdesc:a758ed994bc823ce29001873838384ac0 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a758ed994bc823ce29001873838384ac0">More...</a><br /></td></tr>
+<tr class="separator:a758ed994bc823ce29001873838384ac0 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a> (const T_functor & _A_functor)</td></tr>
+<tr class="memdesc:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an adaptor that wraps the passed functor. <a href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">More...</a><br /></td></tr>
+<tr class="separator:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1track__obj__functor1"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1track__obj__functor1')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td></tr>
+<tr class="memitem:ab36332c8e8815546730b525f739d9ebf inherit pub_types_classsigc_1_1track__obj__functor1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adapts.html">adapts</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#ab36332c8e8815546730b525f739d9ebf">adaptor_type</a></td></tr>
+<tr class="separator:ab36332c8e8815546730b525f739d9ebf inherit pub_types_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17ad87a124cb6fafc37a2d573d47f222 inherit pub_types_classsigc_1_1track__obj__functor1"><td class="memItemLeft" align="right" valign="top">typedef adaptor_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a17ad87a124cb6fafc37a2d573d47f222">result_type</a></td></tr>
+<tr class="separator:a17ad87a124cb6fafc37a2d573d47f222 inherit pub_types_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td></tr>
+<tr class="separator:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td></tr>
+<tr class="separator:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_attribs_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td></tr>
+<tr class="memdesc:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that is invoked from operator()(). <a href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">More...</a><br /></td></tr>
+<tr class="separator:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3><br />
+class sigc::track_obj_functor3< T_functor, T_obj1, T_obj2, T_obj3 ></h3>
+
+<p><a class="el" href="classsigc_1_1track__obj__functor3.html" title="track_obj_functor3 wraps a functor and stores 3 references to trackable objects.">track_obj_functor3</a> wraps a functor and stores 3 references to trackable objects. </p>
+<p>Use the convenience function <a class="el" href="group__track__obj.html#ga8fd1ab36d123ff83dd4cd8dc58bb28e2" title="Creates an adaptor of type sigc::track_obj_functor1 which wraps a functor.">track_obj()</a> to create an instance of <a class="el" href="classsigc_1_1track__obj__functor3.html" title="track_obj_functor3 wraps a functor and stores 3 references to trackable objects.">track_obj_functor3</a>.</p>
+<dl class="tparams"><dt>Template Parameters</dt><dd>
+ <table class="tparams">
+ <tr><td class="paramname">T_functor</td><td>The type of functor to wrap. </td></tr>
+ <tr><td class="paramname">T_obj1</td><td>The type of a trackable object. </td></tr>
+ <tr><td class="paramname">T_obj2</td><td>The type of a trackable object. </td></tr>
+ <tr><td class="paramname">T_obj3</td><td>The type of a trackable object.</td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="since_2_4"><dt><b><a class="el" href="since_2_4.html#_since_2_4000004">Since libsigc++ 2.4:</a></b></dt><dd></dd></dl>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="add83622dc2ad7cd561d2c59768eea45a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#add83622dc2ad7cd561d2c59768eea45a">◆ </a></span>track_obj_functor3()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_functor , typename T_obj1 , typename T_obj2 , typename T_obj3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1track__obj__functor3.html">sigc::track_obj_functor3</a>< T_functor, T_obj1, T_obj2, T_obj3 >::<a class="el" href="classsigc_1_1track__obj__functor3.html">track_obj_functor3</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj1 & </td>
+ <td class="paramname"><em>_A_obj1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj2 & </td>
+ <td class="paramname"><em>_A_obj2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj3 & </td>
+ <td class="paramname"><em>_A_obj3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1track__obj__functor3.html" title="track_obj_functor3 wraps a functor and stores 3 references to trackable objects.">track_obj_functor3</a> object that wraps the passed functor and stores references to the passed trackable objects. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Functor. </td></tr>
+ <tr><td class="paramname">_A_obj1</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj2</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj3</td><td>Trackable object. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::track_obj_functor3< T_functor, T_obj1, T_obj2, T_obj3 >" name="sigc::track_obj_functor3< T_functor, T_obj1, T_obj2, T_obj3 >">
+<area shape="rect" id="node1" title="track_obj_functor3 wraps a functor and stores 3 references to trackable objects." alt="" coords="12,319,189,375"/>
+<area shape="rect" id="node2" href="$classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object." alt="" coords="12,229,189,271"/>
+<area shape="rect" id="node3" href="$structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="5,155,196,181"/>
+<area shape="rect" id="node4" href="$structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="29,80,173,107"/>
+<area shape="rect" id="node5" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="31,5,171,32"/>
+</map>
--- /dev/null
+d8603d0c48e43a11a66425d492d0f5f8
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1track__obj__functor4.html">track_obj_functor4</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::track_obj_functor4< T_functor, T_obj1, T_obj2, T_obj3, T_obj4 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1track__obj__functor4.html">sigc::track_obj_functor4< T_functor, T_obj1, T_obj2, T_obj3, T_obj4 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#ab36332c8e8815546730b525f739d9ebf">adaptor_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a>(const T_functor & _A_functor)</td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a3a4b2ca8d1c83356dcf7d5ba93051986">operator()</a>()</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a3da19bfd10f0b9f84ae83b06f8211ae6">operator()</a>(T_arg1 _A_arg1)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a933452a80a7c98d4865624d2f60b2527">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#abb1206272535caa14e1109d198ab0b1f">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a94fba99da25a041007a4f2f07b19c784">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a8bf05204e43be21b027a79ffb7aed13e">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a610d215dd82c2a3112aef9bb29edd856">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a758ed994bc823ce29001873838384ac0">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6, T_arg7 _A_arg7)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a17ad87a124cb6fafc37a2d573d47f222">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a1bcc00d3b665af8f40fa18936fab5304">track_obj_functor1</a>(const T_functor & _A_func, const T_obj1 & _A_obj1)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor4.html#a29f48beae82cf67da9b70a51da35a2e9">track_obj_functor4</a>(const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2, const T_obj3 & _A_obj3, const T_obj4 & _A_obj4)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor4.html">sigc::track_obj_functor4< T_functor, T_obj1, T_obj2, T_obj3, T_obj4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::track_obj_functor4< T_functor, T_obj1, T_obj2, T_obj3, T_obj4 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1track__obj__functor4.html">track_obj_functor4</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1track__obj__functor4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::track_obj_functor4< T_functor, T_obj1, T_obj2, T_obj3, T_obj4 > Class Template Reference<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a> » <a class="el" href="group__track__obj.html">track_obj()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1track__obj__functor4.html" title="track_obj_functor4 wraps a functor and stores 4 references to trackable objects.">track_obj_functor4</a> wraps a functor and stores 4 references to trackable objects.
+ <a href="classsigc_1_1track__obj__functor4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/track_obj.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::track_obj_functor4< T_functor, T_obj1, T_obj2, T_obj3, T_obj4 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1track__obj__functor4__inherit__graph.png" border="0" usemap="#asigc_1_1track__obj__functor4_3_01T__functor_00_01T__obj1_00_01T__obj2_00_01T__obj3_00_01T__obj4_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1track__obj__functor4_3_01T__functor_00_01T__obj1_00_01T__obj2_00_01T__obj3_00_01T__obj4_01_4_inherit__map" id="asigc_1_1track__obj__functor4_3_01T__functor_00_01T__obj1_00_01T__obj2_00_01T__obj3_00_01T__obj4_01_4_inherit__map">
+<area shape="rect" title="track_obj_functor4 wraps a functor and stores 4 references to trackable objects." alt="" coords="12,319,189,375"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object." alt="" coords="12,229,189,271"/>
+<area shape="rect" href="structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="5,155,196,181"/>
+<area shape="rect" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="29,80,173,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="31,5,171,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a29f48beae82cf67da9b70a51da35a2e9"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor4.html#a29f48beae82cf67da9b70a51da35a2e9">track_obj_functor4</a> (const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2, const T_obj3 & _A_obj3, const T_obj4 & _A_obj4)</td></tr>
+<tr class="memdesc:a29f48beae82cf67da9b70a51da35a2e9"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1track__obj__functor4.html" title="track_obj_functor4 wraps a functor and stores 4 references to trackable objects.">track_obj_functor4</a> object that wraps the passed functor and stores references to the passed trackable objects. <a href="classsigc_1_1track__obj__functor4.html#a29f48beae82cf67da9b70a51da35a2e9">More...</a><br /></td></tr>
+<tr class="separator:a29f48beae82cf67da9b70a51da35a2e9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1track__obj__functor1"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1track__obj__functor1')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td></tr>
+<tr class="memitem:a1bcc00d3b665af8f40fa18936fab5304 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a1bcc00d3b665af8f40fa18936fab5304">track_obj_functor1</a> (const T_functor & _A_func, const T_obj1 & _A_obj1)</td></tr>
+<tr class="memdesc:a1bcc00d3b665af8f40fa18936fab5304 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object.">track_obj_functor1</a> object that wraps the passed functor and stores a reference to the passed trackable object. <a href="classsigc_1_1track__obj__functor1.html#a1bcc00d3b665af8f40fa18936fab5304">More...</a><br /></td></tr>
+<tr class="separator:a1bcc00d3b665af8f40fa18936fab5304 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3a4b2ca8d1c83356dcf7d5ba93051986 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a3a4b2ca8d1c83356dcf7d5ba93051986">operator()</a> ()</td></tr>
+<tr class="memdesc:a3a4b2ca8d1c83356dcf7d5ba93051986 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor. <a href="classsigc_1_1track__obj__functor1.html#a3a4b2ca8d1c83356dcf7d5ba93051986">More...</a><br /></td></tr>
+<tr class="separator:a3a4b2ca8d1c83356dcf7d5ba93051986 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3da19bfd10f0b9f84ae83b06f8211ae6 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 > </td></tr>
+<tr class="memitem:a3da19bfd10f0b9f84ae83b06f8211ae6 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a3da19bfd10f0b9f84ae83b06f8211ae6">operator()</a> (T_arg1 _A_arg1)</td></tr>
+<tr class="memdesc:a3da19bfd10f0b9f84ae83b06f8211ae6 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a3da19bfd10f0b9f84ae83b06f8211ae6">More...</a><br /></td></tr>
+<tr class="separator:a3da19bfd10f0b9f84ae83b06f8211ae6 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a933452a80a7c98d4865624d2f60b2527 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 > </td></tr>
+<tr class="memitem:a933452a80a7c98d4865624d2f60b2527 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a933452a80a7c98d4865624d2f60b2527">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2)</td></tr>
+<tr class="memdesc:a933452a80a7c98d4865624d2f60b2527 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a933452a80a7c98d4865624d2f60b2527">More...</a><br /></td></tr>
+<tr class="separator:a933452a80a7c98d4865624d2f60b2527 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abb1206272535caa14e1109d198ab0b1f inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 > </td></tr>
+<tr class="memitem:abb1206272535caa14e1109d198ab0b1f inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#abb1206272535caa14e1109d198ab0b1f">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)</td></tr>
+<tr class="memdesc:abb1206272535caa14e1109d198ab0b1f inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#abb1206272535caa14e1109d198ab0b1f">More...</a><br /></td></tr>
+<tr class="separator:abb1206272535caa14e1109d198ab0b1f inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a94fba99da25a041007a4f2f07b19c784 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 > </td></tr>
+<tr class="memitem:a94fba99da25a041007a4f2f07b19c784 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a94fba99da25a041007a4f2f07b19c784">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)</td></tr>
+<tr class="memdesc:a94fba99da25a041007a4f2f07b19c784 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a94fba99da25a041007a4f2f07b19c784">More...</a><br /></td></tr>
+<tr class="separator:a94fba99da25a041007a4f2f07b19c784 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8bf05204e43be21b027a79ffb7aed13e inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 , typename T_arg5 > </td></tr>
+<tr class="memitem:a8bf05204e43be21b027a79ffb7aed13e inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a8bf05204e43be21b027a79ffb7aed13e">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)</td></tr>
+<tr class="memdesc:a8bf05204e43be21b027a79ffb7aed13e inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a8bf05204e43be21b027a79ffb7aed13e">More...</a><br /></td></tr>
+<tr class="separator:a8bf05204e43be21b027a79ffb7aed13e inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a610d215dd82c2a3112aef9bb29edd856 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 , typename T_arg5 , typename T_arg6 > </td></tr>
+<tr class="memitem:a610d215dd82c2a3112aef9bb29edd856 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a610d215dd82c2a3112aef9bb29edd856">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)</td></tr>
+<tr class="memdesc:a610d215dd82c2a3112aef9bb29edd856 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a610d215dd82c2a3112aef9bb29edd856">More...</a><br /></td></tr>
+<tr class="separator:a610d215dd82c2a3112aef9bb29edd856 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a758ed994bc823ce29001873838384ac0 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 , typename T_arg5 , typename T_arg6 , typename T_arg7 > </td></tr>
+<tr class="memitem:a758ed994bc823ce29001873838384ac0 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a758ed994bc823ce29001873838384ac0">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6, T_arg7 _A_arg7)</td></tr>
+<tr class="memdesc:a758ed994bc823ce29001873838384ac0 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a758ed994bc823ce29001873838384ac0">More...</a><br /></td></tr>
+<tr class="separator:a758ed994bc823ce29001873838384ac0 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a> (const T_functor & _A_functor)</td></tr>
+<tr class="memdesc:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an adaptor that wraps the passed functor. <a href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">More...</a><br /></td></tr>
+<tr class="separator:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1track__obj__functor1"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1track__obj__functor1')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td></tr>
+<tr class="memitem:ab36332c8e8815546730b525f739d9ebf inherit pub_types_classsigc_1_1track__obj__functor1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adapts.html">adapts</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#ab36332c8e8815546730b525f739d9ebf">adaptor_type</a></td></tr>
+<tr class="separator:ab36332c8e8815546730b525f739d9ebf inherit pub_types_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17ad87a124cb6fafc37a2d573d47f222 inherit pub_types_classsigc_1_1track__obj__functor1"><td class="memItemLeft" align="right" valign="top">typedef adaptor_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a17ad87a124cb6fafc37a2d573d47f222">result_type</a></td></tr>
+<tr class="separator:a17ad87a124cb6fafc37a2d573d47f222 inherit pub_types_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td></tr>
+<tr class="separator:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td></tr>
+<tr class="separator:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_attribs_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td></tr>
+<tr class="memdesc:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that is invoked from operator()(). <a href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">More...</a><br /></td></tr>
+<tr class="separator:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3, typename T_obj4><br />
+class sigc::track_obj_functor4< T_functor, T_obj1, T_obj2, T_obj3, T_obj4 ></h3>
+
+<p><a class="el" href="classsigc_1_1track__obj__functor4.html" title="track_obj_functor4 wraps a functor and stores 4 references to trackable objects.">track_obj_functor4</a> wraps a functor and stores 4 references to trackable objects. </p>
+<p>Use the convenience function <a class="el" href="group__track__obj.html#ga8fd1ab36d123ff83dd4cd8dc58bb28e2" title="Creates an adaptor of type sigc::track_obj_functor1 which wraps a functor.">track_obj()</a> to create an instance of <a class="el" href="classsigc_1_1track__obj__functor4.html" title="track_obj_functor4 wraps a functor and stores 4 references to trackable objects.">track_obj_functor4</a>.</p>
+<dl class="tparams"><dt>Template Parameters</dt><dd>
+ <table class="tparams">
+ <tr><td class="paramname">T_functor</td><td>The type of functor to wrap. </td></tr>
+ <tr><td class="paramname">T_obj1</td><td>The type of a trackable object. </td></tr>
+ <tr><td class="paramname">T_obj2</td><td>The type of a trackable object. </td></tr>
+ <tr><td class="paramname">T_obj3</td><td>The type of a trackable object. </td></tr>
+ <tr><td class="paramname">T_obj4</td><td>The type of a trackable object.</td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="since_2_4"><dt><b><a class="el" href="since_2_4.html#_since_2_4000005">Since libsigc++ 2.4:</a></b></dt><dd></dd></dl>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a29f48beae82cf67da9b70a51da35a2e9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a29f48beae82cf67da9b70a51da35a2e9">◆ </a></span>track_obj_functor4()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_functor , typename T_obj1 , typename T_obj2 , typename T_obj3 , typename T_obj4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1track__obj__functor4.html">sigc::track_obj_functor4</a>< T_functor, T_obj1, T_obj2, T_obj3, T_obj4 >::<a class="el" href="classsigc_1_1track__obj__functor4.html">track_obj_functor4</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj1 & </td>
+ <td class="paramname"><em>_A_obj1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj2 & </td>
+ <td class="paramname"><em>_A_obj2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj3 & </td>
+ <td class="paramname"><em>_A_obj3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj4 & </td>
+ <td class="paramname"><em>_A_obj4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1track__obj__functor4.html" title="track_obj_functor4 wraps a functor and stores 4 references to trackable objects.">track_obj_functor4</a> object that wraps the passed functor and stores references to the passed trackable objects. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Functor. </td></tr>
+ <tr><td class="paramname">_A_obj1</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj2</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj3</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj4</td><td>Trackable object. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::track_obj_functor4< T_functor, T_obj1, T_obj2, T_obj3, T_obj4 >" name="sigc::track_obj_functor4< T_functor, T_obj1, T_obj2, T_obj3, T_obj4 >">
+<area shape="rect" id="node1" title="track_obj_functor4 wraps a functor and stores 4 references to trackable objects." alt="" coords="12,319,189,375"/>
+<area shape="rect" id="node2" href="$classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object." alt="" coords="12,229,189,271"/>
+<area shape="rect" id="node3" href="$structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="5,155,196,181"/>
+<area shape="rect" id="node4" href="$structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="29,80,173,107"/>
+<area shape="rect" id="node5" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="31,5,171,32"/>
+</map>
--- /dev/null
+c65085d466e886bb6cea46ecd8082e2e
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1track__obj__functor5.html">track_obj_functor5</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::track_obj_functor5< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1track__obj__functor5.html">sigc::track_obj_functor5< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#ab36332c8e8815546730b525f739d9ebf">adaptor_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a>(const T_functor & _A_functor)</td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a3a4b2ca8d1c83356dcf7d5ba93051986">operator()</a>()</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a3da19bfd10f0b9f84ae83b06f8211ae6">operator()</a>(T_arg1 _A_arg1)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a933452a80a7c98d4865624d2f60b2527">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#abb1206272535caa14e1109d198ab0b1f">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a94fba99da25a041007a4f2f07b19c784">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a8bf05204e43be21b027a79ffb7aed13e">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a610d215dd82c2a3112aef9bb29edd856">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a758ed994bc823ce29001873838384ac0">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6, T_arg7 _A_arg7)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a17ad87a124cb6fafc37a2d573d47f222">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a1bcc00d3b665af8f40fa18936fab5304">track_obj_functor1</a>(const T_functor & _A_func, const T_obj1 & _A_obj1)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor5.html#a1f0481289e8c48acc4cc6561c8f0c8b6">track_obj_functor5</a>(const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2, const T_obj3 & _A_obj3, const T_obj4 & _A_obj4, const T_obj5 & _A_obj5)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor5.html">sigc::track_obj_functor5< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::track_obj_functor5< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1track__obj__functor5.html">track_obj_functor5</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1track__obj__functor5-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::track_obj_functor5< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5 > Class Template Reference<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a> » <a class="el" href="group__track__obj.html">track_obj()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1track__obj__functor5.html" title="track_obj_functor5 wraps a functor and stores 5 references to trackable objects.">track_obj_functor5</a> wraps a functor and stores 5 references to trackable objects.
+ <a href="classsigc_1_1track__obj__functor5.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/track_obj.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::track_obj_functor5< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1track__obj__functor5__inherit__graph.png" border="0" usemap="#asigc_1_1track__obj__functor5_3_01T__functor_00_01T__obj1_00_01T__obj2_00_01T__obj3_00_01T__obj4_00_01T__obj5_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1track__obj__functor5_3_01T__functor_00_01T__obj1_00_01T__obj2_00_01T__obj3_00_01T__obj4_00_01T__obj5_01_4_inherit__map" id="asigc_1_1track__obj__functor5_3_01T__functor_00_01T__obj1_00_01T__obj2_00_01T__obj3_00_01T__obj4_00_01T__obj5_01_4_inherit__map">
+<area shape="rect" title="track_obj_functor5 wraps a functor and stores 5 references to trackable objects." alt="" coords="5,319,231,375"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object." alt="" coords="29,229,207,271"/>
+<area shape="rect" href="structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="23,155,213,181"/>
+<area shape="rect" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="46,80,190,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="48,5,188,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a1f0481289e8c48acc4cc6561c8f0c8b6"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor5.html#a1f0481289e8c48acc4cc6561c8f0c8b6">track_obj_functor5</a> (const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2, const T_obj3 & _A_obj3, const T_obj4 & _A_obj4, const T_obj5 & _A_obj5)</td></tr>
+<tr class="memdesc:a1f0481289e8c48acc4cc6561c8f0c8b6"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1track__obj__functor5.html" title="track_obj_functor5 wraps a functor and stores 5 references to trackable objects.">track_obj_functor5</a> object that wraps the passed functor and stores references to the passed trackable objects. <a href="classsigc_1_1track__obj__functor5.html#a1f0481289e8c48acc4cc6561c8f0c8b6">More...</a><br /></td></tr>
+<tr class="separator:a1f0481289e8c48acc4cc6561c8f0c8b6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1track__obj__functor1"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1track__obj__functor1')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td></tr>
+<tr class="memitem:a1bcc00d3b665af8f40fa18936fab5304 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a1bcc00d3b665af8f40fa18936fab5304">track_obj_functor1</a> (const T_functor & _A_func, const T_obj1 & _A_obj1)</td></tr>
+<tr class="memdesc:a1bcc00d3b665af8f40fa18936fab5304 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object.">track_obj_functor1</a> object that wraps the passed functor and stores a reference to the passed trackable object. <a href="classsigc_1_1track__obj__functor1.html#a1bcc00d3b665af8f40fa18936fab5304">More...</a><br /></td></tr>
+<tr class="separator:a1bcc00d3b665af8f40fa18936fab5304 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3a4b2ca8d1c83356dcf7d5ba93051986 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a3a4b2ca8d1c83356dcf7d5ba93051986">operator()</a> ()</td></tr>
+<tr class="memdesc:a3a4b2ca8d1c83356dcf7d5ba93051986 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor. <a href="classsigc_1_1track__obj__functor1.html#a3a4b2ca8d1c83356dcf7d5ba93051986">More...</a><br /></td></tr>
+<tr class="separator:a3a4b2ca8d1c83356dcf7d5ba93051986 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3da19bfd10f0b9f84ae83b06f8211ae6 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 > </td></tr>
+<tr class="memitem:a3da19bfd10f0b9f84ae83b06f8211ae6 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a3da19bfd10f0b9f84ae83b06f8211ae6">operator()</a> (T_arg1 _A_arg1)</td></tr>
+<tr class="memdesc:a3da19bfd10f0b9f84ae83b06f8211ae6 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a3da19bfd10f0b9f84ae83b06f8211ae6">More...</a><br /></td></tr>
+<tr class="separator:a3da19bfd10f0b9f84ae83b06f8211ae6 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a933452a80a7c98d4865624d2f60b2527 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 > </td></tr>
+<tr class="memitem:a933452a80a7c98d4865624d2f60b2527 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a933452a80a7c98d4865624d2f60b2527">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2)</td></tr>
+<tr class="memdesc:a933452a80a7c98d4865624d2f60b2527 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a933452a80a7c98d4865624d2f60b2527">More...</a><br /></td></tr>
+<tr class="separator:a933452a80a7c98d4865624d2f60b2527 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abb1206272535caa14e1109d198ab0b1f inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 > </td></tr>
+<tr class="memitem:abb1206272535caa14e1109d198ab0b1f inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#abb1206272535caa14e1109d198ab0b1f">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)</td></tr>
+<tr class="memdesc:abb1206272535caa14e1109d198ab0b1f inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#abb1206272535caa14e1109d198ab0b1f">More...</a><br /></td></tr>
+<tr class="separator:abb1206272535caa14e1109d198ab0b1f inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a94fba99da25a041007a4f2f07b19c784 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 > </td></tr>
+<tr class="memitem:a94fba99da25a041007a4f2f07b19c784 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a94fba99da25a041007a4f2f07b19c784">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)</td></tr>
+<tr class="memdesc:a94fba99da25a041007a4f2f07b19c784 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a94fba99da25a041007a4f2f07b19c784">More...</a><br /></td></tr>
+<tr class="separator:a94fba99da25a041007a4f2f07b19c784 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8bf05204e43be21b027a79ffb7aed13e inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 , typename T_arg5 > </td></tr>
+<tr class="memitem:a8bf05204e43be21b027a79ffb7aed13e inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a8bf05204e43be21b027a79ffb7aed13e">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)</td></tr>
+<tr class="memdesc:a8bf05204e43be21b027a79ffb7aed13e inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a8bf05204e43be21b027a79ffb7aed13e">More...</a><br /></td></tr>
+<tr class="separator:a8bf05204e43be21b027a79ffb7aed13e inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a610d215dd82c2a3112aef9bb29edd856 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 , typename T_arg5 , typename T_arg6 > </td></tr>
+<tr class="memitem:a610d215dd82c2a3112aef9bb29edd856 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a610d215dd82c2a3112aef9bb29edd856">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)</td></tr>
+<tr class="memdesc:a610d215dd82c2a3112aef9bb29edd856 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a610d215dd82c2a3112aef9bb29edd856">More...</a><br /></td></tr>
+<tr class="separator:a610d215dd82c2a3112aef9bb29edd856 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a758ed994bc823ce29001873838384ac0 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 , typename T_arg5 , typename T_arg6 , typename T_arg7 > </td></tr>
+<tr class="memitem:a758ed994bc823ce29001873838384ac0 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a758ed994bc823ce29001873838384ac0">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6, T_arg7 _A_arg7)</td></tr>
+<tr class="memdesc:a758ed994bc823ce29001873838384ac0 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a758ed994bc823ce29001873838384ac0">More...</a><br /></td></tr>
+<tr class="separator:a758ed994bc823ce29001873838384ac0 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a> (const T_functor & _A_functor)</td></tr>
+<tr class="memdesc:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an adaptor that wraps the passed functor. <a href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">More...</a><br /></td></tr>
+<tr class="separator:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1track__obj__functor1"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1track__obj__functor1')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td></tr>
+<tr class="memitem:ab36332c8e8815546730b525f739d9ebf inherit pub_types_classsigc_1_1track__obj__functor1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adapts.html">adapts</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#ab36332c8e8815546730b525f739d9ebf">adaptor_type</a></td></tr>
+<tr class="separator:ab36332c8e8815546730b525f739d9ebf inherit pub_types_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17ad87a124cb6fafc37a2d573d47f222 inherit pub_types_classsigc_1_1track__obj__functor1"><td class="memItemLeft" align="right" valign="top">typedef adaptor_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a17ad87a124cb6fafc37a2d573d47f222">result_type</a></td></tr>
+<tr class="separator:a17ad87a124cb6fafc37a2d573d47f222 inherit pub_types_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td></tr>
+<tr class="separator:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td></tr>
+<tr class="separator:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_attribs_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td></tr>
+<tr class="memdesc:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that is invoked from operator()(). <a href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">More...</a><br /></td></tr>
+<tr class="separator:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3, typename T_obj4, typename T_obj5><br />
+class sigc::track_obj_functor5< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5 ></h3>
+
+<p><a class="el" href="classsigc_1_1track__obj__functor5.html" title="track_obj_functor5 wraps a functor and stores 5 references to trackable objects.">track_obj_functor5</a> wraps a functor and stores 5 references to trackable objects. </p>
+<p>Use the convenience function <a class="el" href="group__track__obj.html#ga8fd1ab36d123ff83dd4cd8dc58bb28e2" title="Creates an adaptor of type sigc::track_obj_functor1 which wraps a functor.">track_obj()</a> to create an instance of <a class="el" href="classsigc_1_1track__obj__functor5.html" title="track_obj_functor5 wraps a functor and stores 5 references to trackable objects.">track_obj_functor5</a>.</p>
+<dl class="tparams"><dt>Template Parameters</dt><dd>
+ <table class="tparams">
+ <tr><td class="paramname">T_functor</td><td>The type of functor to wrap. </td></tr>
+ <tr><td class="paramname">T_obj1</td><td>The type of a trackable object. </td></tr>
+ <tr><td class="paramname">T_obj2</td><td>The type of a trackable object. </td></tr>
+ <tr><td class="paramname">T_obj3</td><td>The type of a trackable object. </td></tr>
+ <tr><td class="paramname">T_obj4</td><td>The type of a trackable object. </td></tr>
+ <tr><td class="paramname">T_obj5</td><td>The type of a trackable object.</td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="since_2_4"><dt><b><a class="el" href="since_2_4.html#_since_2_4000006">Since libsigc++ 2.4:</a></b></dt><dd></dd></dl>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a1f0481289e8c48acc4cc6561c8f0c8b6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1f0481289e8c48acc4cc6561c8f0c8b6">◆ </a></span>track_obj_functor5()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_functor , typename T_obj1 , typename T_obj2 , typename T_obj3 , typename T_obj4 , typename T_obj5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1track__obj__functor5.html">sigc::track_obj_functor5</a>< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5 >::<a class="el" href="classsigc_1_1track__obj__functor5.html">track_obj_functor5</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj1 & </td>
+ <td class="paramname"><em>_A_obj1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj2 & </td>
+ <td class="paramname"><em>_A_obj2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj3 & </td>
+ <td class="paramname"><em>_A_obj3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj4 & </td>
+ <td class="paramname"><em>_A_obj4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj5 & </td>
+ <td class="paramname"><em>_A_obj5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1track__obj__functor5.html" title="track_obj_functor5 wraps a functor and stores 5 references to trackable objects.">track_obj_functor5</a> object that wraps the passed functor and stores references to the passed trackable objects. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Functor. </td></tr>
+ <tr><td class="paramname">_A_obj1</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj2</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj3</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj4</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj5</td><td>Trackable object. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::track_obj_functor5< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5 >" name="sigc::track_obj_functor5< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5 >">
+<area shape="rect" id="node1" title="track_obj_functor5 wraps a functor and stores 5 references to trackable objects." alt="" coords="5,319,231,375"/>
+<area shape="rect" id="node2" href="$classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object." alt="" coords="29,229,207,271"/>
+<area shape="rect" id="node3" href="$structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="23,155,213,181"/>
+<area shape="rect" id="node4" href="$structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="46,80,190,107"/>
+<area shape="rect" id="node5" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="48,5,188,32"/>
+</map>
--- /dev/null
+e7bdd29378bb120d3efb62f3f07cf8b0
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1track__obj__functor6.html">track_obj_functor6</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::track_obj_functor6< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1track__obj__functor6.html">sigc::track_obj_functor6< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#ab36332c8e8815546730b525f739d9ebf">adaptor_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a>(const T_functor & _A_functor)</td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a3a4b2ca8d1c83356dcf7d5ba93051986">operator()</a>()</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a3da19bfd10f0b9f84ae83b06f8211ae6">operator()</a>(T_arg1 _A_arg1)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a933452a80a7c98d4865624d2f60b2527">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#abb1206272535caa14e1109d198ab0b1f">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a94fba99da25a041007a4f2f07b19c784">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a8bf05204e43be21b027a79ffb7aed13e">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a610d215dd82c2a3112aef9bb29edd856">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a758ed994bc823ce29001873838384ac0">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6, T_arg7 _A_arg7)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a17ad87a124cb6fafc37a2d573d47f222">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a1bcc00d3b665af8f40fa18936fab5304">track_obj_functor1</a>(const T_functor & _A_func, const T_obj1 & _A_obj1)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor6.html#a70b36db3f8cafb77c48269c3e4c68714">track_obj_functor6</a>(const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2, const T_obj3 & _A_obj3, const T_obj4 & _A_obj4, const T_obj5 & _A_obj5, const T_obj6 & _A_obj6)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor6.html">sigc::track_obj_functor6< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::track_obj_functor6< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1track__obj__functor6.html">track_obj_functor6</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1track__obj__functor6-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::track_obj_functor6< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6 > Class Template Reference<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a> » <a class="el" href="group__track__obj.html">track_obj()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1track__obj__functor6.html" title="track_obj_functor6 wraps a functor and stores 6 references to trackable objects.">track_obj_functor6</a> wraps a functor and stores 6 references to trackable objects.
+ <a href="classsigc_1_1track__obj__functor6.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/track_obj.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::track_obj_functor6< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1track__obj__functor6__inherit__graph.png" border="0" usemap="#asigc_1_1track__obj__functor6_3_01T__functor_00_01T__obj1_00_01T__obj2_00_01T__obj3_00_01T__obj4_00_01T__obj5_00_01T__obj6_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1track__obj__functor6_3_01T__functor_00_01T__obj1_00_01T__obj2_00_01T__obj3_00_01T__obj4_00_01T__obj5_00_01T__obj6_01_4_inherit__map" id="asigc_1_1track__obj__functor6_3_01T__functor_00_01T__obj1_00_01T__obj2_00_01T__obj3_00_01T__obj4_00_01T__obj5_00_01T__obj6_01_4_inherit__map">
+<area shape="rect" title="track_obj_functor6 wraps a functor and stores 6 references to trackable objects." alt="" coords="12,319,189,389"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object." alt="" coords="12,229,189,271"/>
+<area shape="rect" href="structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="5,155,196,181"/>
+<area shape="rect" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="29,80,173,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="31,5,171,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a70b36db3f8cafb77c48269c3e4c68714"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor6.html#a70b36db3f8cafb77c48269c3e4c68714">track_obj_functor6</a> (const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2, const T_obj3 & _A_obj3, const T_obj4 & _A_obj4, const T_obj5 & _A_obj5, const T_obj6 & _A_obj6)</td></tr>
+<tr class="memdesc:a70b36db3f8cafb77c48269c3e4c68714"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1track__obj__functor6.html" title="track_obj_functor6 wraps a functor and stores 6 references to trackable objects.">track_obj_functor6</a> object that wraps the passed functor and stores references to the passed trackable objects. <a href="classsigc_1_1track__obj__functor6.html#a70b36db3f8cafb77c48269c3e4c68714">More...</a><br /></td></tr>
+<tr class="separator:a70b36db3f8cafb77c48269c3e4c68714"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1track__obj__functor1"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1track__obj__functor1')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td></tr>
+<tr class="memitem:a1bcc00d3b665af8f40fa18936fab5304 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a1bcc00d3b665af8f40fa18936fab5304">track_obj_functor1</a> (const T_functor & _A_func, const T_obj1 & _A_obj1)</td></tr>
+<tr class="memdesc:a1bcc00d3b665af8f40fa18936fab5304 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object.">track_obj_functor1</a> object that wraps the passed functor and stores a reference to the passed trackable object. <a href="classsigc_1_1track__obj__functor1.html#a1bcc00d3b665af8f40fa18936fab5304">More...</a><br /></td></tr>
+<tr class="separator:a1bcc00d3b665af8f40fa18936fab5304 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3a4b2ca8d1c83356dcf7d5ba93051986 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a3a4b2ca8d1c83356dcf7d5ba93051986">operator()</a> ()</td></tr>
+<tr class="memdesc:a3a4b2ca8d1c83356dcf7d5ba93051986 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor. <a href="classsigc_1_1track__obj__functor1.html#a3a4b2ca8d1c83356dcf7d5ba93051986">More...</a><br /></td></tr>
+<tr class="separator:a3a4b2ca8d1c83356dcf7d5ba93051986 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3da19bfd10f0b9f84ae83b06f8211ae6 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 > </td></tr>
+<tr class="memitem:a3da19bfd10f0b9f84ae83b06f8211ae6 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a3da19bfd10f0b9f84ae83b06f8211ae6">operator()</a> (T_arg1 _A_arg1)</td></tr>
+<tr class="memdesc:a3da19bfd10f0b9f84ae83b06f8211ae6 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a3da19bfd10f0b9f84ae83b06f8211ae6">More...</a><br /></td></tr>
+<tr class="separator:a3da19bfd10f0b9f84ae83b06f8211ae6 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a933452a80a7c98d4865624d2f60b2527 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 > </td></tr>
+<tr class="memitem:a933452a80a7c98d4865624d2f60b2527 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a933452a80a7c98d4865624d2f60b2527">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2)</td></tr>
+<tr class="memdesc:a933452a80a7c98d4865624d2f60b2527 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a933452a80a7c98d4865624d2f60b2527">More...</a><br /></td></tr>
+<tr class="separator:a933452a80a7c98d4865624d2f60b2527 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abb1206272535caa14e1109d198ab0b1f inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 > </td></tr>
+<tr class="memitem:abb1206272535caa14e1109d198ab0b1f inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#abb1206272535caa14e1109d198ab0b1f">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)</td></tr>
+<tr class="memdesc:abb1206272535caa14e1109d198ab0b1f inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#abb1206272535caa14e1109d198ab0b1f">More...</a><br /></td></tr>
+<tr class="separator:abb1206272535caa14e1109d198ab0b1f inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a94fba99da25a041007a4f2f07b19c784 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 > </td></tr>
+<tr class="memitem:a94fba99da25a041007a4f2f07b19c784 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a94fba99da25a041007a4f2f07b19c784">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)</td></tr>
+<tr class="memdesc:a94fba99da25a041007a4f2f07b19c784 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a94fba99da25a041007a4f2f07b19c784">More...</a><br /></td></tr>
+<tr class="separator:a94fba99da25a041007a4f2f07b19c784 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8bf05204e43be21b027a79ffb7aed13e inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 , typename T_arg5 > </td></tr>
+<tr class="memitem:a8bf05204e43be21b027a79ffb7aed13e inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a8bf05204e43be21b027a79ffb7aed13e">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)</td></tr>
+<tr class="memdesc:a8bf05204e43be21b027a79ffb7aed13e inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a8bf05204e43be21b027a79ffb7aed13e">More...</a><br /></td></tr>
+<tr class="separator:a8bf05204e43be21b027a79ffb7aed13e inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a610d215dd82c2a3112aef9bb29edd856 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 , typename T_arg5 , typename T_arg6 > </td></tr>
+<tr class="memitem:a610d215dd82c2a3112aef9bb29edd856 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a610d215dd82c2a3112aef9bb29edd856">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)</td></tr>
+<tr class="memdesc:a610d215dd82c2a3112aef9bb29edd856 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a610d215dd82c2a3112aef9bb29edd856">More...</a><br /></td></tr>
+<tr class="separator:a610d215dd82c2a3112aef9bb29edd856 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a758ed994bc823ce29001873838384ac0 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 , typename T_arg5 , typename T_arg6 , typename T_arg7 > </td></tr>
+<tr class="memitem:a758ed994bc823ce29001873838384ac0 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a758ed994bc823ce29001873838384ac0">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6, T_arg7 _A_arg7)</td></tr>
+<tr class="memdesc:a758ed994bc823ce29001873838384ac0 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a758ed994bc823ce29001873838384ac0">More...</a><br /></td></tr>
+<tr class="separator:a758ed994bc823ce29001873838384ac0 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a> (const T_functor & _A_functor)</td></tr>
+<tr class="memdesc:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an adaptor that wraps the passed functor. <a href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">More...</a><br /></td></tr>
+<tr class="separator:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1track__obj__functor1"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1track__obj__functor1')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td></tr>
+<tr class="memitem:ab36332c8e8815546730b525f739d9ebf inherit pub_types_classsigc_1_1track__obj__functor1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adapts.html">adapts</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#ab36332c8e8815546730b525f739d9ebf">adaptor_type</a></td></tr>
+<tr class="separator:ab36332c8e8815546730b525f739d9ebf inherit pub_types_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17ad87a124cb6fafc37a2d573d47f222 inherit pub_types_classsigc_1_1track__obj__functor1"><td class="memItemLeft" align="right" valign="top">typedef adaptor_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a17ad87a124cb6fafc37a2d573d47f222">result_type</a></td></tr>
+<tr class="separator:a17ad87a124cb6fafc37a2d573d47f222 inherit pub_types_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td></tr>
+<tr class="separator:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td></tr>
+<tr class="separator:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_attribs_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td></tr>
+<tr class="memdesc:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that is invoked from operator()(). <a href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">More...</a><br /></td></tr>
+<tr class="separator:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3, typename T_obj4, typename T_obj5, typename T_obj6><br />
+class sigc::track_obj_functor6< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6 ></h3>
+
+<p><a class="el" href="classsigc_1_1track__obj__functor6.html" title="track_obj_functor6 wraps a functor and stores 6 references to trackable objects.">track_obj_functor6</a> wraps a functor and stores 6 references to trackable objects. </p>
+<p>Use the convenience function <a class="el" href="group__track__obj.html#ga8fd1ab36d123ff83dd4cd8dc58bb28e2" title="Creates an adaptor of type sigc::track_obj_functor1 which wraps a functor.">track_obj()</a> to create an instance of <a class="el" href="classsigc_1_1track__obj__functor6.html" title="track_obj_functor6 wraps a functor and stores 6 references to trackable objects.">track_obj_functor6</a>.</p>
+<dl class="tparams"><dt>Template Parameters</dt><dd>
+ <table class="tparams">
+ <tr><td class="paramname">T_functor</td><td>The type of functor to wrap. </td></tr>
+ <tr><td class="paramname">T_obj1</td><td>The type of a trackable object. </td></tr>
+ <tr><td class="paramname">T_obj2</td><td>The type of a trackable object. </td></tr>
+ <tr><td class="paramname">T_obj3</td><td>The type of a trackable object. </td></tr>
+ <tr><td class="paramname">T_obj4</td><td>The type of a trackable object. </td></tr>
+ <tr><td class="paramname">T_obj5</td><td>The type of a trackable object. </td></tr>
+ <tr><td class="paramname">T_obj6</td><td>The type of a trackable object.</td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="since_2_4"><dt><b><a class="el" href="since_2_4.html#_since_2_4000007">Since libsigc++ 2.4:</a></b></dt><dd></dd></dl>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a70b36db3f8cafb77c48269c3e4c68714"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a70b36db3f8cafb77c48269c3e4c68714">◆ </a></span>track_obj_functor6()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_functor , typename T_obj1 , typename T_obj2 , typename T_obj3 , typename T_obj4 , typename T_obj5 , typename T_obj6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1track__obj__functor6.html">sigc::track_obj_functor6</a>< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6 >::<a class="el" href="classsigc_1_1track__obj__functor6.html">track_obj_functor6</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj1 & </td>
+ <td class="paramname"><em>_A_obj1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj2 & </td>
+ <td class="paramname"><em>_A_obj2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj3 & </td>
+ <td class="paramname"><em>_A_obj3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj4 & </td>
+ <td class="paramname"><em>_A_obj4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj5 & </td>
+ <td class="paramname"><em>_A_obj5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj6 & </td>
+ <td class="paramname"><em>_A_obj6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1track__obj__functor6.html" title="track_obj_functor6 wraps a functor and stores 6 references to trackable objects.">track_obj_functor6</a> object that wraps the passed functor and stores references to the passed trackable objects. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Functor. </td></tr>
+ <tr><td class="paramname">_A_obj1</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj2</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj3</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj4</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj5</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj6</td><td>Trackable object. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::track_obj_functor6< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6 >" name="sigc::track_obj_functor6< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6 >">
+<area shape="rect" id="node1" title="track_obj_functor6 wraps a functor and stores 6 references to trackable objects." alt="" coords="12,319,189,389"/>
+<area shape="rect" id="node2" href="$classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object." alt="" coords="12,229,189,271"/>
+<area shape="rect" id="node3" href="$structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="5,155,196,181"/>
+<area shape="rect" id="node4" href="$structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="29,80,173,107"/>
+<area shape="rect" id="node5" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="31,5,171,32"/>
+</map>
--- /dev/null
+6a587408ac57c2c7db306079e8845ce4
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1track__obj__functor7.html">track_obj_functor7</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::track_obj_functor7< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6, T_obj7 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1track__obj__functor7.html">sigc::track_obj_functor7< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6, T_obj7 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#ab36332c8e8815546730b525f739d9ebf">adaptor_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a>(const T_functor & _A_functor)</td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a3a4b2ca8d1c83356dcf7d5ba93051986">operator()</a>()</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a3da19bfd10f0b9f84ae83b06f8211ae6">operator()</a>(T_arg1 _A_arg1)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a933452a80a7c98d4865624d2f60b2527">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#abb1206272535caa14e1109d198ab0b1f">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a94fba99da25a041007a4f2f07b19c784">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a8bf05204e43be21b027a79ffb7aed13e">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a610d215dd82c2a3112aef9bb29edd856">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a758ed994bc823ce29001873838384ac0">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6, T_arg7 _A_arg7)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a17ad87a124cb6fafc37a2d573d47f222">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html#a1bcc00d3b665af8f40fa18936fab5304">track_obj_functor1</a>(const T_functor & _A_func, const T_obj1 & _A_obj1)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor7.html#a77667be610a480c7afdb928533b02651">track_obj_functor7</a>(const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2, const T_obj3 & _A_obj3, const T_obj4 & _A_obj4, const T_obj5 & _A_obj5, const T_obj6 & _A_obj6, const T_obj7 & _A_obj7)</td><td class="entry"><a class="el" href="classsigc_1_1track__obj__functor7.html">sigc::track_obj_functor7< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6, T_obj7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::track_obj_functor7< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6, T_obj7 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1track__obj__functor7.html">track_obj_functor7</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1track__obj__functor7-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::track_obj_functor7< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6, T_obj7 > Class Template Reference<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a> » <a class="el" href="group__track__obj.html">track_obj()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1track__obj__functor7.html" title="track_obj_functor7 wraps a functor and stores 7 references to trackable objects.">track_obj_functor7</a> wraps a functor and stores 7 references to trackable objects.
+ <a href="classsigc_1_1track__obj__functor7.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/track_obj.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::track_obj_functor7< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6, T_obj7 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1track__obj__functor7__inherit__graph.png" border="0" usemap="#asigc_1_1track__obj__functor7_3_01T__functor_00_01T__obj1_00_01T__obj2_00_01T__obj3_00_01T__obj4_00_01T__obj5_00_01T__obj6_00_01T__obj7_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1track__obj__functor7_3_01T__functor_00_01T__obj1_00_01T__obj2_00_01T__obj3_00_01T__obj4_00_01T__obj5_00_01T__obj6_00_01T__obj7_01_4_inherit__map" id="asigc_1_1track__obj__functor7_3_01T__functor_00_01T__obj1_00_01T__obj2_00_01T__obj3_00_01T__obj4_00_01T__obj5_00_01T__obj6_00_01T__obj7_01_4_inherit__map">
+<area shape="rect" title="track_obj_functor7 wraps a functor and stores 7 references to trackable objects." alt="" coords="12,319,189,389"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object." alt="" coords="12,229,189,271"/>
+<area shape="rect" href="structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="5,155,196,181"/>
+<area shape="rect" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="29,80,173,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="31,5,171,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a77667be610a480c7afdb928533b02651"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor7.html#a77667be610a480c7afdb928533b02651">track_obj_functor7</a> (const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2, const T_obj3 & _A_obj3, const T_obj4 & _A_obj4, const T_obj5 & _A_obj5, const T_obj6 & _A_obj6, const T_obj7 & _A_obj7)</td></tr>
+<tr class="memdesc:a77667be610a480c7afdb928533b02651"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1track__obj__functor7.html" title="track_obj_functor7 wraps a functor and stores 7 references to trackable objects.">track_obj_functor7</a> object that wraps the passed functor and stores references to the passed trackable objects. <a href="classsigc_1_1track__obj__functor7.html#a77667be610a480c7afdb928533b02651">More...</a><br /></td></tr>
+<tr class="separator:a77667be610a480c7afdb928533b02651"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_classsigc_1_1track__obj__functor1"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classsigc_1_1track__obj__functor1')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td></tr>
+<tr class="memitem:a1bcc00d3b665af8f40fa18936fab5304 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a1bcc00d3b665af8f40fa18936fab5304">track_obj_functor1</a> (const T_functor & _A_func, const T_obj1 & _A_obj1)</td></tr>
+<tr class="memdesc:a1bcc00d3b665af8f40fa18936fab5304 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object.">track_obj_functor1</a> object that wraps the passed functor and stores a reference to the passed trackable object. <a href="classsigc_1_1track__obj__functor1.html#a1bcc00d3b665af8f40fa18936fab5304">More...</a><br /></td></tr>
+<tr class="separator:a1bcc00d3b665af8f40fa18936fab5304 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3a4b2ca8d1c83356dcf7d5ba93051986 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a3a4b2ca8d1c83356dcf7d5ba93051986">operator()</a> ()</td></tr>
+<tr class="memdesc:a3a4b2ca8d1c83356dcf7d5ba93051986 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor. <a href="classsigc_1_1track__obj__functor1.html#a3a4b2ca8d1c83356dcf7d5ba93051986">More...</a><br /></td></tr>
+<tr class="separator:a3a4b2ca8d1c83356dcf7d5ba93051986 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3da19bfd10f0b9f84ae83b06f8211ae6 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 > </td></tr>
+<tr class="memitem:a3da19bfd10f0b9f84ae83b06f8211ae6 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a3da19bfd10f0b9f84ae83b06f8211ae6">operator()</a> (T_arg1 _A_arg1)</td></tr>
+<tr class="memdesc:a3da19bfd10f0b9f84ae83b06f8211ae6 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a3da19bfd10f0b9f84ae83b06f8211ae6">More...</a><br /></td></tr>
+<tr class="separator:a3da19bfd10f0b9f84ae83b06f8211ae6 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a933452a80a7c98d4865624d2f60b2527 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 > </td></tr>
+<tr class="memitem:a933452a80a7c98d4865624d2f60b2527 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a933452a80a7c98d4865624d2f60b2527">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2)</td></tr>
+<tr class="memdesc:a933452a80a7c98d4865624d2f60b2527 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a933452a80a7c98d4865624d2f60b2527">More...</a><br /></td></tr>
+<tr class="separator:a933452a80a7c98d4865624d2f60b2527 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abb1206272535caa14e1109d198ab0b1f inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 > </td></tr>
+<tr class="memitem:abb1206272535caa14e1109d198ab0b1f inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#abb1206272535caa14e1109d198ab0b1f">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)</td></tr>
+<tr class="memdesc:abb1206272535caa14e1109d198ab0b1f inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#abb1206272535caa14e1109d198ab0b1f">More...</a><br /></td></tr>
+<tr class="separator:abb1206272535caa14e1109d198ab0b1f inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a94fba99da25a041007a4f2f07b19c784 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 > </td></tr>
+<tr class="memitem:a94fba99da25a041007a4f2f07b19c784 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a94fba99da25a041007a4f2f07b19c784">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)</td></tr>
+<tr class="memdesc:a94fba99da25a041007a4f2f07b19c784 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a94fba99da25a041007a4f2f07b19c784">More...</a><br /></td></tr>
+<tr class="separator:a94fba99da25a041007a4f2f07b19c784 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8bf05204e43be21b027a79ffb7aed13e inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 , typename T_arg5 > </td></tr>
+<tr class="memitem:a8bf05204e43be21b027a79ffb7aed13e inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a8bf05204e43be21b027a79ffb7aed13e">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)</td></tr>
+<tr class="memdesc:a8bf05204e43be21b027a79ffb7aed13e inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a8bf05204e43be21b027a79ffb7aed13e">More...</a><br /></td></tr>
+<tr class="separator:a8bf05204e43be21b027a79ffb7aed13e inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a610d215dd82c2a3112aef9bb29edd856 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 , typename T_arg5 , typename T_arg6 > </td></tr>
+<tr class="memitem:a610d215dd82c2a3112aef9bb29edd856 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a610d215dd82c2a3112aef9bb29edd856">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)</td></tr>
+<tr class="memdesc:a610d215dd82c2a3112aef9bb29edd856 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a610d215dd82c2a3112aef9bb29edd856">More...</a><br /></td></tr>
+<tr class="separator:a610d215dd82c2a3112aef9bb29edd856 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a758ed994bc823ce29001873838384ac0 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplParams" colspan="2">template<typename T_arg1 , typename T_arg2 , typename T_arg3 , typename T_arg4 , typename T_arg5 , typename T_arg6 , typename T_arg7 > </td></tr>
+<tr class="memitem:a758ed994bc823ce29001873838384ac0 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a758ed994bc823ce29001873838384ac0">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6, T_arg7 _A_arg7)</td></tr>
+<tr class="memdesc:a758ed994bc823ce29001873838384ac0 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="classsigc_1_1track__obj__functor1.html#a758ed994bc823ce29001873838384ac0">More...</a><br /></td></tr>
+<tr class="separator:a758ed994bc823ce29001873838384ac0 inherit pub_methods_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a> (const T_functor & _A_functor)</td></tr>
+<tr class="memdesc:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an adaptor that wraps the passed functor. <a href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">More...</a><br /></td></tr>
+<tr class="separator:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_types_classsigc_1_1track__obj__functor1"><td colspan="2" onclick="javascript:toggleInherit('pub_types_classsigc_1_1track__obj__functor1')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td></tr>
+<tr class="memitem:ab36332c8e8815546730b525f739d9ebf inherit pub_types_classsigc_1_1track__obj__functor1"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adapts.html">adapts</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#ab36332c8e8815546730b525f739d9ebf">adaptor_type</a></td></tr>
+<tr class="separator:ab36332c8e8815546730b525f739d9ebf inherit pub_types_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17ad87a124cb6fafc37a2d573d47f222 inherit pub_types_classsigc_1_1track__obj__functor1"><td class="memItemLeft" align="right" valign="top">typedef adaptor_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html#a17ad87a124cb6fafc37a2d573d47f222">result_type</a></td></tr>
+<tr class="separator:a17ad87a124cb6fafc37a2d573d47f222 inherit pub_types_classsigc_1_1track__obj__functor1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td></tr>
+<tr class="separator:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td></tr>
+<tr class="separator:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_attribs_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td></tr>
+<tr class="memdesc:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that is invoked from operator()(). <a href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">More...</a><br /></td></tr>
+<tr class="separator:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3, typename T_obj4, typename T_obj5, typename T_obj6, typename T_obj7><br />
+class sigc::track_obj_functor7< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6, T_obj7 ></h3>
+
+<p><a class="el" href="classsigc_1_1track__obj__functor7.html" title="track_obj_functor7 wraps a functor and stores 7 references to trackable objects.">track_obj_functor7</a> wraps a functor and stores 7 references to trackable objects. </p>
+<p>Use the convenience function <a class="el" href="group__track__obj.html#ga8fd1ab36d123ff83dd4cd8dc58bb28e2" title="Creates an adaptor of type sigc::track_obj_functor1 which wraps a functor.">track_obj()</a> to create an instance of <a class="el" href="classsigc_1_1track__obj__functor7.html" title="track_obj_functor7 wraps a functor and stores 7 references to trackable objects.">track_obj_functor7</a>.</p>
+<dl class="tparams"><dt>Template Parameters</dt><dd>
+ <table class="tparams">
+ <tr><td class="paramname">T_functor</td><td>The type of functor to wrap. </td></tr>
+ <tr><td class="paramname">T_obj1</td><td>The type of a trackable object. </td></tr>
+ <tr><td class="paramname">T_obj2</td><td>The type of a trackable object. </td></tr>
+ <tr><td class="paramname">T_obj3</td><td>The type of a trackable object. </td></tr>
+ <tr><td class="paramname">T_obj4</td><td>The type of a trackable object. </td></tr>
+ <tr><td class="paramname">T_obj5</td><td>The type of a trackable object. </td></tr>
+ <tr><td class="paramname">T_obj6</td><td>The type of a trackable object. </td></tr>
+ <tr><td class="paramname">T_obj7</td><td>The type of a trackable object.</td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="since_2_4"><dt><b><a class="el" href="since_2_4.html#_since_2_4000008">Since libsigc++ 2.4:</a></b></dt><dd></dd></dl>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a77667be610a480c7afdb928533b02651"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a77667be610a480c7afdb928533b02651">◆ </a></span>track_obj_functor7()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_functor , typename T_obj1 , typename T_obj2 , typename T_obj3 , typename T_obj4 , typename T_obj5 , typename T_obj6 , typename T_obj7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1track__obj__functor7.html">sigc::track_obj_functor7</a>< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6, T_obj7 >::<a class="el" href="classsigc_1_1track__obj__functor7.html">track_obj_functor7</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj1 & </td>
+ <td class="paramname"><em>_A_obj1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj2 & </td>
+ <td class="paramname"><em>_A_obj2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj3 & </td>
+ <td class="paramname"><em>_A_obj3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj4 & </td>
+ <td class="paramname"><em>_A_obj4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj5 & </td>
+ <td class="paramname"><em>_A_obj5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj6 & </td>
+ <td class="paramname"><em>_A_obj6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj7 & </td>
+ <td class="paramname"><em>_A_obj7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1track__obj__functor7.html" title="track_obj_functor7 wraps a functor and stores 7 references to trackable objects.">track_obj_functor7</a> object that wraps the passed functor and stores references to the passed trackable objects. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Functor. </td></tr>
+ <tr><td class="paramname">_A_obj1</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj2</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj3</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj4</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj5</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj6</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj7</td><td>Trackable object. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::track_obj_functor7< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6, T_obj7 >" name="sigc::track_obj_functor7< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6, T_obj7 >">
+<area shape="rect" id="node1" title="track_obj_functor7 wraps a functor and stores 7 references to trackable objects." alt="" coords="12,319,189,389"/>
+<area shape="rect" id="node2" href="$classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object." alt="" coords="12,229,189,271"/>
+<area shape="rect" id="node3" href="$structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="5,155,196,181"/>
+<area shape="rect" id="node4" href="$structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="29,80,173,107"/>
+<area shape="rect" id="node5" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="31,5,171,32"/>
+</map>
--- /dev/null
+e23a89fd776275f3ed89e0665398688f
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1volatile__limit__reference.html">volatile_limit_reference</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::volatile_limit_reference< T_type, I_derives_trackable > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1volatile__limit__reference.html">sigc::volatile_limit_reference< T_type, I_derives_trackable ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__limit__reference.html#a0157cc89d9db4032c7a8f9159ebaeff3">invoke</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__limit__reference.html">sigc::volatile_limit_reference< T_type, I_derives_trackable ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__limit__reference.html#a4d67fe2d9d27c326136a9e5ac13a1a75">visit</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__limit__reference.html">sigc::volatile_limit_reference< T_type, I_derives_trackable ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__limit__reference.html#acb3e6e1ecc628343f94faae718b58066">volatile_limit_reference</a>(T_type & _A_target)</td><td class="entry"><a class="el" href="classsigc_1_1volatile__limit__reference.html">sigc::volatile_limit_reference< T_type, I_derives_trackable ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::volatile_limit_reference< T_type, I_derives_trackable > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1volatile__limit__reference.html">volatile_limit_reference</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1volatile__limit__reference-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::volatile_limit_reference< T_type, I_derives_trackable > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>A volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>, then <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each<>()</a> will "limit" itself to the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference instead of the derived reference.
+ <a href="classsigc_1_1volatile__limit__reference.html#details">More...</a></p>
+
+<p><code>#include <sigc++/limit_reference.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:acb3e6e1ecc628343f94faae718b58066"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__limit__reference.html#acb3e6e1ecc628343f94faae718b58066">volatile_limit_reference</a> (T_type & _A_target)</td></tr>
+<tr class="memdesc:acb3e6e1ecc628343f94faae718b58066"><td class="mdescLeft"> </td><td class="mdescRight">Constructor. <a href="classsigc_1_1volatile__limit__reference.html#acb3e6e1ecc628343f94faae718b58066">More...</a><br /></td></tr>
+<tr class="separator:acb3e6e1ecc628343f94faae718b58066"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0157cc89d9db4032c7a8f9159ebaeff3"><td class="memItemLeft" align="right" valign="top">volatile T_type & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__limit__reference.html#a0157cc89d9db4032c7a8f9159ebaeff3">invoke</a> () const</td></tr>
+<tr class="memdesc:a0157cc89d9db4032c7a8f9159ebaeff3"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the reference. <a href="classsigc_1_1volatile__limit__reference.html#a0157cc89d9db4032c7a8f9159ebaeff3">More...</a><br /></td></tr>
+<tr class="separator:a0157cc89d9db4032c7a8f9159ebaeff3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4d67fe2d9d27c326136a9e5ac13a1a75"><td class="memItemLeft" align="right" valign="top">const T_type & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__limit__reference.html#a4d67fe2d9d27c326136a9e5ac13a1a75">visit</a> () const</td></tr>
+<tr class="memdesc:a4d67fe2d9d27c326136a9e5ac13a1a75"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the entity to visit for <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each()</a>. <a href="classsigc_1_1volatile__limit__reference.html#a4d67fe2d9d27c326136a9e5ac13a1a75">More...</a><br /></td></tr>
+<tr class="separator:a4d67fe2d9d27c326136a9e5ac13a1a75"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_type, bool I_derives_trackable = std::is_base_of<trackable, T_type>::value><br />
+class sigc::volatile_limit_reference< T_type, I_derives_trackable ></h3>
+
+<p>A volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>, then <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each<>()</a> will "limit" itself to the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference instead of the derived reference. </p>
+<p>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.</p>
+<p>If Foo inherits from trackable then both the derived reference and the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference are stored, so we can later retrieve the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference without doing an implicit conversion. To retrieve the derived reference (so that you invoke methods or members of it), use <a class="el" href="classsigc_1_1volatile__limit__reference.html#a0157cc89d9db4032c7a8f9159ebaeff3" title="Retrieve the reference.">invoke()</a>. To retrieve the trackable reference (so that you can call <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each()</a> on it), you use <a class="el" href="classsigc_1_1volatile__limit__reference.html#a4d67fe2d9d27c326136a9e5ac13a1a75" title="Retrieve the entity to visit for visit_each().">visit()</a>.</p>
+<p>If Foo does not inherit from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> then <a class="el" href="classsigc_1_1volatile__limit__reference.html#a0157cc89d9db4032c7a8f9159ebaeff3" title="Retrieve the reference.">invoke()</a> and <a class="el" href="classsigc_1_1volatile__limit__reference.html#a4d67fe2d9d27c326136a9e5ac13a1a75" title="Retrieve the entity to visit for visit_each().">visit()</a> just return the derived reference.</p>
+<p>This is used for bound (<a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">sigc::bind</a>) slot parameters (via <a class="el" href="classsigc_1_1bound__argument.html" title="A bound_argument<Foo> object stores a bound (for instance, with sigc::bind(), or sigc::bind_return())...">bound_argument</a>), bound return values, and, with <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a>, the reference to the handling object.</p>
+<ul>
+<li><em>T_type</em> The type of the reference. </li>
+</ul>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="acb3e6e1ecc628343f94faae718b58066"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#acb3e6e1ecc628343f94faae718b58066">◆ </a></span>volatile_limit_reference()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type , bool I_derives_trackable = std::is_base_of<trackable, T_type>::value> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__limit__reference.html">sigc::volatile_limit_reference</a>< T_type, I_derives_trackable >::<a class="el" href="classsigc_1_1volatile__limit__reference.html">volatile_limit_reference</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_type & </td>
+ <td class="paramname"><em>_A_target</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_target</td><td>The reference to limit. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a0157cc89d9db4032c7a8f9159ebaeff3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0157cc89d9db4032c7a8f9159ebaeff3">◆ </a></span>invoke()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type , bool I_derives_trackable = std::is_base_of<trackable, T_type>::value> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">volatile T_type& <a class="el" href="classsigc_1_1volatile__limit__reference.html">sigc::volatile_limit_reference</a>< T_type, I_derives_trackable >::invoke </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Retrieve the reference. </p>
+<p>This is always a reference to the derived instance. </p><dl class="section return"><dt>Returns</dt><dd>The reference. </dd></dl>
+
+</div>
+</div>
+<a id="a4d67fe2d9d27c326136a9e5ac13a1a75"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4d67fe2d9d27c326136a9e5ac13a1a75">◆ </a></span>visit()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type , bool I_derives_trackable = std::is_base_of<trackable, T_type>::value> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">const T_type& <a class="el" href="classsigc_1_1volatile__limit__reference.html">sigc::volatile_limit_reference</a>< T_type, I_derives_trackable >::visit </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Retrieve the entity to visit for <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each()</a>. </p>
+<p>Depending on the template specialization, this is either a derived reference, or <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>& if T_type derives from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>. </p><dl class="section return"><dt>Returns</dt><dd>The reference. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html">volatile_limit_reference< T_type, true ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::volatile_limit_reference< T_type, true > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html">sigc::volatile_limit_reference< T_type, true ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html#aebad0975106ae62368e4f5c0ee0a6170">invoke</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html">sigc::volatile_limit_reference< T_type, true ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html#a187454d57b2c1edefb5594fcd0175835">visit</a>() const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html">sigc::volatile_limit_reference< T_type, true ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html#aa0b69d0a82616d6db2eb86d7a041df23">volatile_limit_reference</a>(T_type & _A_target)</td><td class="entry"><a class="el" href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html">sigc::volatile_limit_reference< T_type, true ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::volatile_limit_reference< T_type, true > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html">volatile_limit_reference< T_type, true ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::volatile_limit_reference< T_type, true > Class Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1volatile__limit__reference.html" title="A volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that,...">volatile_limit_reference</a> object for a class that derives from trackable.
+ <a href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/limit_reference.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:aa0b69d0a82616d6db2eb86d7a041df23"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html#aa0b69d0a82616d6db2eb86d7a041df23">volatile_limit_reference</a> (T_type & _A_target)</td></tr>
+<tr class="memdesc:aa0b69d0a82616d6db2eb86d7a041df23"><td class="mdescLeft"> </td><td class="mdescRight">Constructor. <a href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html#aa0b69d0a82616d6db2eb86d7a041df23">More...</a><br /></td></tr>
+<tr class="separator:aa0b69d0a82616d6db2eb86d7a041df23"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebad0975106ae62368e4f5c0ee0a6170"><td class="memItemLeft" align="right" valign="top">volatile T_type & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html#aebad0975106ae62368e4f5c0ee0a6170">invoke</a> () const</td></tr>
+<tr class="memdesc:aebad0975106ae62368e4f5c0ee0a6170"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the reference. <a href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html#aebad0975106ae62368e4f5c0ee0a6170">More...</a><br /></td></tr>
+<tr class="separator:aebad0975106ae62368e4f5c0ee0a6170"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a187454d57b2c1edefb5594fcd0175835"><td class="memItemLeft" align="right" valign="top">const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html#a187454d57b2c1edefb5594fcd0175835">visit</a> () const</td></tr>
+<tr class="memdesc:a187454d57b2c1edefb5594fcd0175835"><td class="mdescLeft"> </td><td class="mdescRight">Retrieve the entity to visit for <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each()</a>. <a href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html#a187454d57b2c1edefb5594fcd0175835">More...</a><br /></td></tr>
+<tr class="separator:a187454d57b2c1edefb5594fcd0175835"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_type><br />
+class sigc::volatile_limit_reference< T_type, true ></h3>
+
+<p><a class="el" href="classsigc_1_1volatile__limit__reference.html" title="A volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that,...">volatile_limit_reference</a> object for a class that derives from trackable. </p>
+<ul>
+<li><em>T_type</em> The type of the reference. </li>
+</ul>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="aa0b69d0a82616d6db2eb86d7a041df23"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa0b69d0a82616d6db2eb86d7a041df23">◆ </a></span>volatile_limit_reference()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__limit__reference.html">sigc::volatile_limit_reference</a>< T_type, true >::<a class="el" href="classsigc_1_1volatile__limit__reference.html">volatile_limit_reference</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_type & </td>
+ <td class="paramname"><em>_A_target</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_target</td><td>The reference to limit. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="aebad0975106ae62368e4f5c0ee0a6170"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aebad0975106ae62368e4f5c0ee0a6170">◆ </a></span>invoke()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">volatile T_type& <a class="el" href="classsigc_1_1volatile__limit__reference.html">sigc::volatile_limit_reference</a>< T_type, true >::invoke </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Retrieve the reference. </p>
+<p>This is always a reference to the derived instance. </p><dl class="section return"><dt>Returns</dt><dd>The reference. </dd></dl>
+
+</div>
+</div>
+<a id="a187454d57b2c1edefb5594fcd0175835"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a187454d57b2c1edefb5594fcd0175835">◆ </a></span>visit()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">const <a class="el" href="structsigc_1_1trackable.html">trackable</a>& <a class="el" href="classsigc_1_1volatile__limit__reference.html">sigc::volatile_limit_reference</a>< T_type, true >::visit </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Retrieve the entity to visit for <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each()</a>. </p>
+<p>Depending on the template specialization, this is either a derived reference, or <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>& if T_type derives from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>. </p><dl class="section return"><dt>Returns</dt><dd>The reference. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1volatile__mem__functor0.html">volatile_mem_functor0</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::volatile_mem_functor0< T_return, T_obj > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1volatile__mem__functor0.html">sigc::volatile_mem_functor0< T_return, T_obj ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#a874e91ca403b95bb085ed596257de3ec">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor0.html">sigc::volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#a2f0448d35b580f2b4884292f29b19b2f">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor0.html">sigc::volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#af627ef410fac7ec5d2ee842d8f89fe51">operator()</a>(T_obj * _A_obj) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor0.html">sigc::volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#aa5df40ec8fb385594c673a07f3ff8044">operator()</a>(T_obj & _A_obj) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor0.html">sigc::volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#a41fbd67d6bbde0818b880f08f6295396">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor0.html">sigc::volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#ae29bbe3e668b370d2788631465daa63c">volatile_mem_functor0</a>()</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor0.html">sigc::volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#aa4e5e279480d50940eb4b73b9c61b938">volatile_mem_functor0</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor0.html">sigc::volatile_mem_functor0< T_return, T_obj ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::volatile_mem_functor0< T_return, T_obj > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1volatile__mem__functor0.html">volatile_mem_functor0</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1volatile__mem__functor0-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::volatile_mem_functor0< T_return, T_obj > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1volatile__mem__functor0.html" title="volatile_mem_functor0 wraps volatile methods with 0 argument(s).">volatile_mem_functor0</a> wraps volatile methods with 0 argument(s).
+ <a href="classsigc_1_1volatile__mem__functor0.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::volatile_mem_functor0< T_return, T_obj >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1volatile__mem__functor0__inherit__graph.png" border="0" usemap="#asigc_1_1volatile__mem__functor0_3_01T__return_00_01T__obj_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1volatile__mem__functor0_3_01T__return_00_01T__obj_01_4_inherit__map" id="asigc_1_1volatile__mem__functor0_3_01T__return_00_01T__obj_01_4_inherit__map">
+<area shape="rect" title="volatile_mem_functor0 wraps volatile methods with 0 argument(s)." alt="" coords="26,80,182,136"/>
+<area shape="rect" href="classsigc_1_1bound__volatile__mem__functor0.html" title="bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance." alt="" coords="5,184,203,240"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a2f0448d35b580f2b4884292f29b19b2f"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#a2f0448d35b580f2b4884292f29b19b2f">function_type</a>) () volatile</td></tr>
+<tr class="separator:a2f0448d35b580f2b4884292f29b19b2f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a41fbd67d6bbde0818b880f08f6295396"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#a41fbd67d6bbde0818b880f08f6295396">result_type</a></td></tr>
+<tr class="separator:a41fbd67d6bbde0818b880f08f6295396"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:ae29bbe3e668b370d2788631465daa63c"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#ae29bbe3e668b370d2788631465daa63c">volatile_mem_functor0</a> ()</td></tr>
+<tr class="memdesc:ae29bbe3e668b370d2788631465daa63c"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1volatile__mem__functor0.html#ae29bbe3e668b370d2788631465daa63c">More...</a><br /></td></tr>
+<tr class="separator:ae29bbe3e668b370d2788631465daa63c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa4e5e279480d50940eb4b73b9c61b938"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#aa4e5e279480d50940eb4b73b9c61b938">volatile_mem_functor0</a> (<a class="el" href="classsigc_1_1volatile__mem__functor0.html#a2f0448d35b580f2b4884292f29b19b2f">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:aa4e5e279480d50940eb4b73b9c61b938"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1volatile__mem__functor0.html" title="volatile_mem_functor0 wraps volatile methods with 0 argument(s).">volatile_mem_functor0</a> object that wraps the passed method. <a href="classsigc_1_1volatile__mem__functor0.html#aa4e5e279480d50940eb4b73b9c61b938">More...</a><br /></td></tr>
+<tr class="separator:aa4e5e279480d50940eb4b73b9c61b938"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa5df40ec8fb385594c673a07f3ff8044"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#aa5df40ec8fb385594c673a07f3ff8044">operator()</a> (T_obj & _A_obj) const</td></tr>
+<tr class="memdesc:aa5df40ec8fb385594c673a07f3ff8044"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor0.html#aa5df40ec8fb385594c673a07f3ff8044">More...</a><br /></td></tr>
+<tr class="separator:aa5df40ec8fb385594c673a07f3ff8044"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af627ef410fac7ec5d2ee842d8f89fe51"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#af627ef410fac7ec5d2ee842d8f89fe51">operator()</a> (T_obj * _A_obj) const</td></tr>
+<tr class="memdesc:af627ef410fac7ec5d2ee842d8f89fe51"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor0.html#af627ef410fac7ec5d2ee842d8f89fe51">More...</a><br /></td></tr>
+<tr class="separator:af627ef410fac7ec5d2ee842d8f89fe51"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:a874e91ca403b95bb085ed596257de3ec"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#a2f0448d35b580f2b4884292f29b19b2f">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#a874e91ca403b95bb085ed596257de3ec">func_ptr_</a></td></tr>
+<tr class="separator:a874e91ca403b95bb085ed596257de3ec"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj><br />
+class sigc::volatile_mem_functor0< T_return, T_obj ></h3>
+
+<p><a class="el" href="classsigc_1_1volatile__mem__functor0.html" title="volatile_mem_functor0 wraps volatile methods with 0 argument(s).">volatile_mem_functor0</a> wraps volatile methods with 0 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1volatile__mem__functor0.html" title="volatile_mem_functor0 wraps volatile methods with 0 argument(s).">volatile_mem_functor0</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1volatile__mem__functor0.html#af627ef410fac7ec5d2ee842d8f89fe51" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a2f0448d35b580f2b4884292f29b19b2f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2f0448d35b580f2b4884292f29b19b2f">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1volatile__mem__functor0.html">sigc::volatile_mem_functor0</a>< T_return, T_obj >::function_type) () volatile</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a41fbd67d6bbde0818b880f08f6295396"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a41fbd67d6bbde0818b880f08f6295396">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1volatile__mem__functor0.html">sigc::volatile_mem_functor0</a>< T_return, T_obj >::<a class="el" href="classsigc_1_1volatile__mem__functor0.html#a41fbd67d6bbde0818b880f08f6295396">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="ae29bbe3e668b370d2788631465daa63c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae29bbe3e668b370d2788631465daa63c">◆ </a></span>volatile_mem_functor0() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor0.html">sigc::volatile_mem_functor0</a>< T_return, T_obj >::<a class="el" href="classsigc_1_1volatile__mem__functor0.html">volatile_mem_functor0</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="aa4e5e279480d50940eb4b73b9c61b938"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa4e5e279480d50940eb4b73b9c61b938">◆ </a></span>volatile_mem_functor0() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor0.html">sigc::volatile_mem_functor0</a>< T_return, T_obj >::<a class="el" href="classsigc_1_1volatile__mem__functor0.html">volatile_mem_functor0</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#a2f0448d35b580f2b4884292f29b19b2f">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1volatile__mem__functor0.html" title="volatile_mem_functor0 wraps volatile methods with 0 argument(s).">volatile_mem_functor0</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1volatile__mem__functor0.html#af627ef410fac7ec5d2ee842d8f89fe51" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="aa5df40ec8fb385594c673a07f3ff8044"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa5df40ec8fb385594c673a07f3ff8044">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1volatile__mem__functor0.html">sigc::volatile_mem_functor0</a>< T_return, T_obj >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="af627ef410fac7ec5d2ee842d8f89fe51"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af627ef410fac7ec5d2ee842d8f89fe51">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1volatile__mem__functor0.html">sigc::volatile_mem_functor0</a>< T_return, T_obj >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000146">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a874e91ca403b95bb085ed596257de3ec"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a874e91ca403b95bb085ed596257de3ec">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor0.html#a2f0448d35b580f2b4884292f29b19b2f">function_type</a> <a class="el" href="classsigc_1_1volatile__mem__functor0.html">sigc::volatile_mem_functor0</a>< T_return, T_obj >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::volatile_mem_functor0< T_return, T_obj >" name="sigc::volatile_mem_functor0< T_return, T_obj >">
+<area shape="rect" id="node1" title="volatile_mem_functor0 wraps volatile methods with 0 argument(s)." alt="" coords="26,80,182,136"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__volatile__mem__functor0.html" title="bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance." alt="" coords="5,184,203,240"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
--- /dev/null
+6203ac20097f7aa3619a83fcf4bcf10b
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1volatile__mem__functor1.html">volatile_mem_functor1</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1volatile__mem__functor1.html">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#ad07b2821f95c27c013af4fdce527c1cb">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor1.html">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#a49228c222297c3f116b132370c3f054d">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor1.html">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#a69185452103c51af81b78e95504eb95c">operator()</a>(T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor1.html">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#a98cdb61b4c623e44d5b60650098bddfd">operator()</a>(T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor1.html">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#a3bcbf6ae6e950d35e4ac7b33fa066877">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor1.html">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#a30ec3be683a2c466b23da53c8025608b">volatile_mem_functor1</a>()</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor1.html">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#a86d592aee0ca1d853b64b52224054029">volatile_mem_functor1</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor1.html">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1volatile__mem__functor1.html">volatile_mem_functor1</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1volatile__mem__functor1-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1volatile__mem__functor1.html" title="volatile_mem_functor1 wraps volatile methods with 1 argument(s).">volatile_mem_functor1</a> wraps volatile methods with 1 argument(s).
+ <a href="classsigc_1_1volatile__mem__functor1.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1volatile__mem__functor1__inherit__graph.png" border="0" usemap="#asigc_1_1volatile__mem__functor1_3_01T__return_00_01T__obj_00_01T__arg1_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1volatile__mem__functor1_3_01T__return_00_01T__obj_00_01T__arg1_01_4_inherit__map" id="asigc_1_1volatile__mem__functor1_3_01T__return_00_01T__obj_00_01T__arg1_01_4_inherit__map">
+<area shape="rect" title="volatile_mem_functor1 wraps volatile methods with 1 argument(s)." alt="" coords="26,80,182,136"/>
+<area shape="rect" href="classsigc_1_1bound__volatile__mem__functor1.html" title="bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance." alt="" coords="5,184,203,240"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a49228c222297c3f116b132370c3f054d"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#a49228c222297c3f116b132370c3f054d">function_type</a>) (T_arg1) volatile</td></tr>
+<tr class="separator:a49228c222297c3f116b132370c3f054d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3bcbf6ae6e950d35e4ac7b33fa066877"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#a3bcbf6ae6e950d35e4ac7b33fa066877">result_type</a></td></tr>
+<tr class="separator:a3bcbf6ae6e950d35e4ac7b33fa066877"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a30ec3be683a2c466b23da53c8025608b"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#a30ec3be683a2c466b23da53c8025608b">volatile_mem_functor1</a> ()</td></tr>
+<tr class="memdesc:a30ec3be683a2c466b23da53c8025608b"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1volatile__mem__functor1.html#a30ec3be683a2c466b23da53c8025608b">More...</a><br /></td></tr>
+<tr class="separator:a30ec3be683a2c466b23da53c8025608b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a86d592aee0ca1d853b64b52224054029"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#a86d592aee0ca1d853b64b52224054029">volatile_mem_functor1</a> (<a class="el" href="classsigc_1_1volatile__mem__functor1.html#a49228c222297c3f116b132370c3f054d">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a86d592aee0ca1d853b64b52224054029"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1volatile__mem__functor1.html" title="volatile_mem_functor1 wraps volatile methods with 1 argument(s).">volatile_mem_functor1</a> object that wraps the passed method. <a href="classsigc_1_1volatile__mem__functor1.html#a86d592aee0ca1d853b64b52224054029">More...</a><br /></td></tr>
+<tr class="separator:a86d592aee0ca1d853b64b52224054029"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a98cdb61b4c623e44d5b60650098bddfd"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#a98cdb61b4c623e44d5b60650098bddfd">operator()</a> (T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a98cdb61b4c623e44d5b60650098bddfd"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor1.html#a98cdb61b4c623e44d5b60650098bddfd">More...</a><br /></td></tr>
+<tr class="separator:a98cdb61b4c623e44d5b60650098bddfd"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a69185452103c51af81b78e95504eb95c"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#a69185452103c51af81b78e95504eb95c">operator()</a> (T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1) const</td></tr>
+<tr class="memdesc:a69185452103c51af81b78e95504eb95c"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor1.html#a69185452103c51af81b78e95504eb95c">More...</a><br /></td></tr>
+<tr class="separator:a69185452103c51af81b78e95504eb95c"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:ad07b2821f95c27c013af4fdce527c1cb"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#a49228c222297c3f116b132370c3f054d">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#ad07b2821f95c27c013af4fdce527c1cb">func_ptr_</a></td></tr>
+<tr class="separator:ad07b2821f95c27c013af4fdce527c1cb"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1><br />
+class sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></h3>
+
+<p><a class="el" href="classsigc_1_1volatile__mem__functor1.html" title="volatile_mem_functor1 wraps volatile methods with 1 argument(s).">volatile_mem_functor1</a> wraps volatile methods with 1 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1volatile__mem__functor1.html" title="volatile_mem_functor1 wraps volatile methods with 1 argument(s).">volatile_mem_functor1</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1volatile__mem__functor1.html#a69185452103c51af81b78e95504eb95c" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1volatile__mem__functor1.html#a69185452103c51af81b78e95504eb95c" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a49228c222297c3f116b132370c3f054d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a49228c222297c3f116b132370c3f054d">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1volatile__mem__functor1.html">sigc::volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >::function_type) (T_arg1) volatile</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a3bcbf6ae6e950d35e4ac7b33fa066877"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3bcbf6ae6e950d35e4ac7b33fa066877">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1volatile__mem__functor1.html">sigc::volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >::<a class="el" href="classsigc_1_1volatile__mem__functor1.html#a3bcbf6ae6e950d35e4ac7b33fa066877">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a30ec3be683a2c466b23da53c8025608b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a30ec3be683a2c466b23da53c8025608b">◆ </a></span>volatile_mem_functor1() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor1.html">sigc::volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >::<a class="el" href="classsigc_1_1volatile__mem__functor1.html">volatile_mem_functor1</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="a86d592aee0ca1d853b64b52224054029"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a86d592aee0ca1d853b64b52224054029">◆ </a></span>volatile_mem_functor1() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor1.html">sigc::volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >::<a class="el" href="classsigc_1_1volatile__mem__functor1.html">volatile_mem_functor1</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#a49228c222297c3f116b132370c3f054d">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1volatile__mem__functor1.html" title="volatile_mem_functor1 wraps volatile methods with 1 argument(s).">volatile_mem_functor1</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1volatile__mem__functor1.html#a69185452103c51af81b78e95504eb95c" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a98cdb61b4c623e44d5b60650098bddfd"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a98cdb61b4c623e44d5b60650098bddfd">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1volatile__mem__functor1.html">sigc::volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a69185452103c51af81b78e95504eb95c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a69185452103c51af81b78e95504eb95c">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1volatile__mem__functor1.html">sigc::volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000147">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="ad07b2821f95c27c013af4fdce527c1cb"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad07b2821f95c27c013af4fdce527c1cb">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor1.html#a49228c222297c3f116b132370c3f054d">function_type</a> <a class="el" href="classsigc_1_1volatile__mem__functor1.html">sigc::volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 >" name="sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 >">
+<area shape="rect" id="node1" title="volatile_mem_functor1 wraps volatile methods with 1 argument(s)." alt="" coords="26,80,182,136"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__volatile__mem__functor1.html" title="bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance." alt="" coords="5,184,203,240"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
--- /dev/null
+d84d297debbdbed3b75304d0ba6dbaab
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1volatile__mem__functor2.html">volatile_mem_functor2</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1volatile__mem__functor2.html">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#aafe942fe06b2687338ea82b058412d07">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor2.html">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#a5faa6d84f05d64ff92e9e4ba6b8bcc1f">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor2.html">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#ac4c64a4812347e17744e33e5e37775d7">operator()</a>(T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor2.html">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#a814c8abe52fa858da9f8dfbda8efafc9">operator()</a>(T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor2.html">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#a67719071ed0eacd994fa6fe300cfb24d">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor2.html">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#a273bbe27bc7b190d8457408cd328c1f9">volatile_mem_functor2</a>()</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor2.html">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#acba5e052ebb8884ff02cab194a2f794e">volatile_mem_functor2</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor2.html">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1volatile__mem__functor2.html">volatile_mem_functor2</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1volatile__mem__functor2-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1volatile__mem__functor2.html" title="volatile_mem_functor2 wraps volatile methods with 2 argument(s).">volatile_mem_functor2</a> wraps volatile methods with 2 argument(s).
+ <a href="classsigc_1_1volatile__mem__functor2.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1volatile__mem__functor2__inherit__graph.png" border="0" usemap="#asigc_1_1volatile__mem__functor2_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1volatile__mem__functor2_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_01_4_inherit__map" id="asigc_1_1volatile__mem__functor2_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_01_4_inherit__map">
+<area shape="rect" title="volatile_mem_functor2 wraps volatile methods with 2 argument(s)." alt="" coords="14,80,194,136"/>
+<area shape="rect" href="classsigc_1_1bound__volatile__mem__functor2.html" title="bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance." alt="" coords="5,184,203,240"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a5faa6d84f05d64ff92e9e4ba6b8bcc1f"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#a5faa6d84f05d64ff92e9e4ba6b8bcc1f">function_type</a>) (T_arg1, T_arg2) volatile</td></tr>
+<tr class="separator:a5faa6d84f05d64ff92e9e4ba6b8bcc1f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a67719071ed0eacd994fa6fe300cfb24d"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#a67719071ed0eacd994fa6fe300cfb24d">result_type</a></td></tr>
+<tr class="separator:a67719071ed0eacd994fa6fe300cfb24d"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a273bbe27bc7b190d8457408cd328c1f9"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#a273bbe27bc7b190d8457408cd328c1f9">volatile_mem_functor2</a> ()</td></tr>
+<tr class="memdesc:a273bbe27bc7b190d8457408cd328c1f9"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1volatile__mem__functor2.html#a273bbe27bc7b190d8457408cd328c1f9">More...</a><br /></td></tr>
+<tr class="separator:a273bbe27bc7b190d8457408cd328c1f9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acba5e052ebb8884ff02cab194a2f794e"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#acba5e052ebb8884ff02cab194a2f794e">volatile_mem_functor2</a> (<a class="el" href="classsigc_1_1volatile__mem__functor2.html#a5faa6d84f05d64ff92e9e4ba6b8bcc1f">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:acba5e052ebb8884ff02cab194a2f794e"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1volatile__mem__functor2.html" title="volatile_mem_functor2 wraps volatile methods with 2 argument(s).">volatile_mem_functor2</a> object that wraps the passed method. <a href="classsigc_1_1volatile__mem__functor2.html#acba5e052ebb8884ff02cab194a2f794e">More...</a><br /></td></tr>
+<tr class="separator:acba5e052ebb8884ff02cab194a2f794e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a814c8abe52fa858da9f8dfbda8efafc9"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#a814c8abe52fa858da9f8dfbda8efafc9">operator()</a> (T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:a814c8abe52fa858da9f8dfbda8efafc9"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor2.html#a814c8abe52fa858da9f8dfbda8efafc9">More...</a><br /></td></tr>
+<tr class="separator:a814c8abe52fa858da9f8dfbda8efafc9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac4c64a4812347e17744e33e5e37775d7"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#ac4c64a4812347e17744e33e5e37775d7">operator()</a> (T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2) const</td></tr>
+<tr class="memdesc:ac4c64a4812347e17744e33e5e37775d7"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor2.html#ac4c64a4812347e17744e33e5e37775d7">More...</a><br /></td></tr>
+<tr class="separator:ac4c64a4812347e17744e33e5e37775d7"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:aafe942fe06b2687338ea82b058412d07"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#a5faa6d84f05d64ff92e9e4ba6b8bcc1f">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#aafe942fe06b2687338ea82b058412d07">func_ptr_</a></td></tr>
+<tr class="separator:aafe942fe06b2687338ea82b058412d07"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2><br />
+class sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></h3>
+
+<p><a class="el" href="classsigc_1_1volatile__mem__functor2.html" title="volatile_mem_functor2 wraps volatile methods with 2 argument(s).">volatile_mem_functor2</a> wraps volatile methods with 2 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1volatile__mem__functor2.html" title="volatile_mem_functor2 wraps volatile methods with 2 argument(s).">volatile_mem_functor2</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1volatile__mem__functor2.html#ac4c64a4812347e17744e33e5e37775d7" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1volatile__mem__functor2.html#ac4c64a4812347e17744e33e5e37775d7" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1volatile__mem__functor2.html#ac4c64a4812347e17744e33e5e37775d7" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a5faa6d84f05d64ff92e9e4ba6b8bcc1f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5faa6d84f05d64ff92e9e4ba6b8bcc1f">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1volatile__mem__functor2.html">sigc::volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::function_type) (T_arg1, T_arg2) volatile</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a67719071ed0eacd994fa6fe300cfb24d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a67719071ed0eacd994fa6fe300cfb24d">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1volatile__mem__functor2.html">sigc::volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1volatile__mem__functor2.html#a67719071ed0eacd994fa6fe300cfb24d">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a273bbe27bc7b190d8457408cd328c1f9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a273bbe27bc7b190d8457408cd328c1f9">◆ </a></span>volatile_mem_functor2() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor2.html">sigc::volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1volatile__mem__functor2.html">volatile_mem_functor2</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="acba5e052ebb8884ff02cab194a2f794e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#acba5e052ebb8884ff02cab194a2f794e">◆ </a></span>volatile_mem_functor2() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor2.html">sigc::volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::<a class="el" href="classsigc_1_1volatile__mem__functor2.html">volatile_mem_functor2</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#a5faa6d84f05d64ff92e9e4ba6b8bcc1f">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1volatile__mem__functor2.html" title="volatile_mem_functor2 wraps volatile methods with 2 argument(s).">volatile_mem_functor2</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1volatile__mem__functor2.html#ac4c64a4812347e17744e33e5e37775d7" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a814c8abe52fa858da9f8dfbda8efafc9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a814c8abe52fa858da9f8dfbda8efafc9">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1volatile__mem__functor2.html">sigc::volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="ac4c64a4812347e17744e33e5e37775d7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac4c64a4812347e17744e33e5e37775d7">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1volatile__mem__functor2.html">sigc::volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000148">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="aafe942fe06b2687338ea82b058412d07"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aafe942fe06b2687338ea82b058412d07">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor2.html#a5faa6d84f05d64ff92e9e4ba6b8bcc1f">function_type</a> <a class="el" href="classsigc_1_1volatile__mem__functor2.html">sigc::volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >" name="sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >">
+<area shape="rect" id="node1" title="volatile_mem_functor2 wraps volatile methods with 2 argument(s)." alt="" coords="14,80,194,136"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__volatile__mem__functor2.html" title="bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance." alt="" coords="5,184,203,240"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
--- /dev/null
+a3c875d0a5e21a4c2be7948a3d345da9
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1volatile__mem__functor3.html">volatile_mem_functor3</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1volatile__mem__functor3.html">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#acf6a8aebcf4de461e03e9b994a807362">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor3.html">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#aadf62624c12ef82ade8114184f0882c9">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor3.html">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#a39944451f3bb1538828e45b66f082ea0">operator()</a>(T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor3.html">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#ab525bf6e0a4057a4f3f8f98ff6c1bd74">operator()</a>(T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor3.html">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#a229fe43026e97bbcf80215ea8e9fa828">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor3.html">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#ad2319eebf06194ff516c27f581cbd7a5">volatile_mem_functor3</a>()</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor3.html">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#a2364e6ab68a8128ba9e9973c66c0ce1d">volatile_mem_functor3</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor3.html">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1volatile__mem__functor3.html">volatile_mem_functor3</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1volatile__mem__functor3-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1volatile__mem__functor3.html" title="volatile_mem_functor3 wraps volatile methods with 3 argument(s).">volatile_mem_functor3</a> wraps volatile methods with 3 argument(s).
+ <a href="classsigc_1_1volatile__mem__functor3.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1volatile__mem__functor3__inherit__graph.png" border="0" usemap="#asigc_1_1volatile__mem__functor3_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1volatile__mem__functor3_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_01_4_inherit__map" id="asigc_1_1volatile__mem__functor3_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_01_4_inherit__map">
+<area shape="rect" title="volatile_mem_functor3 wraps volatile methods with 3 argument(s)." alt="" coords="19,80,189,151"/>
+<area shape="rect" href="classsigc_1_1bound__volatile__mem__functor3.html" title="bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance." alt="" coords="5,199,203,269"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:aadf62624c12ef82ade8114184f0882c9"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#aadf62624c12ef82ade8114184f0882c9">function_type</a>) (T_arg1, T_arg2, T_arg3) volatile</td></tr>
+<tr class="separator:aadf62624c12ef82ade8114184f0882c9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a229fe43026e97bbcf80215ea8e9fa828"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#a229fe43026e97bbcf80215ea8e9fa828">result_type</a></td></tr>
+<tr class="separator:a229fe43026e97bbcf80215ea8e9fa828"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:ad2319eebf06194ff516c27f581cbd7a5"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#ad2319eebf06194ff516c27f581cbd7a5">volatile_mem_functor3</a> ()</td></tr>
+<tr class="memdesc:ad2319eebf06194ff516c27f581cbd7a5"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1volatile__mem__functor3.html#ad2319eebf06194ff516c27f581cbd7a5">More...</a><br /></td></tr>
+<tr class="separator:ad2319eebf06194ff516c27f581cbd7a5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2364e6ab68a8128ba9e9973c66c0ce1d"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#a2364e6ab68a8128ba9e9973c66c0ce1d">volatile_mem_functor3</a> (<a class="el" href="classsigc_1_1volatile__mem__functor3.html#aadf62624c12ef82ade8114184f0882c9">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a2364e6ab68a8128ba9e9973c66c0ce1d"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1volatile__mem__functor3.html" title="volatile_mem_functor3 wraps volatile methods with 3 argument(s).">volatile_mem_functor3</a> object that wraps the passed method. <a href="classsigc_1_1volatile__mem__functor3.html#a2364e6ab68a8128ba9e9973c66c0ce1d">More...</a><br /></td></tr>
+<tr class="separator:a2364e6ab68a8128ba9e9973c66c0ce1d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab525bf6e0a4057a4f3f8f98ff6c1bd74"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#ab525bf6e0a4057a4f3f8f98ff6c1bd74">operator()</a> (T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:ab525bf6e0a4057a4f3f8f98ff6c1bd74"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor3.html#ab525bf6e0a4057a4f3f8f98ff6c1bd74">More...</a><br /></td></tr>
+<tr class="separator:ab525bf6e0a4057a4f3f8f98ff6c1bd74"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a39944451f3bb1538828e45b66f082ea0"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#a39944451f3bb1538828e45b66f082ea0">operator()</a> (T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3) const</td></tr>
+<tr class="memdesc:a39944451f3bb1538828e45b66f082ea0"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor3.html#a39944451f3bb1538828e45b66f082ea0">More...</a><br /></td></tr>
+<tr class="separator:a39944451f3bb1538828e45b66f082ea0"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:acf6a8aebcf4de461e03e9b994a807362"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#aadf62624c12ef82ade8114184f0882c9">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#acf6a8aebcf4de461e03e9b994a807362">func_ptr_</a></td></tr>
+<tr class="separator:acf6a8aebcf4de461e03e9b994a807362"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3><br />
+class sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></h3>
+
+<p><a class="el" href="classsigc_1_1volatile__mem__functor3.html" title="volatile_mem_functor3 wraps volatile methods with 3 argument(s).">volatile_mem_functor3</a> wraps volatile methods with 3 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1volatile__mem__functor3.html" title="volatile_mem_functor3 wraps volatile methods with 3 argument(s).">volatile_mem_functor3</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1volatile__mem__functor3.html#a39944451f3bb1538828e45b66f082ea0" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1volatile__mem__functor3.html#a39944451f3bb1538828e45b66f082ea0" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1volatile__mem__functor3.html#a39944451f3bb1538828e45b66f082ea0" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1volatile__mem__functor3.html#a39944451f3bb1538828e45b66f082ea0" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="aadf62624c12ef82ade8114184f0882c9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aadf62624c12ef82ade8114184f0882c9">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1volatile__mem__functor3.html">sigc::volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::function_type) (T_arg1, T_arg2, T_arg3) volatile</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a229fe43026e97bbcf80215ea8e9fa828"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a229fe43026e97bbcf80215ea8e9fa828">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1volatile__mem__functor3.html">sigc::volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1volatile__mem__functor3.html#a229fe43026e97bbcf80215ea8e9fa828">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="ad2319eebf06194ff516c27f581cbd7a5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad2319eebf06194ff516c27f581cbd7a5">◆ </a></span>volatile_mem_functor3() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor3.html">sigc::volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1volatile__mem__functor3.html">volatile_mem_functor3</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="a2364e6ab68a8128ba9e9973c66c0ce1d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2364e6ab68a8128ba9e9973c66c0ce1d">◆ </a></span>volatile_mem_functor3() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor3.html">sigc::volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::<a class="el" href="classsigc_1_1volatile__mem__functor3.html">volatile_mem_functor3</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#aadf62624c12ef82ade8114184f0882c9">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1volatile__mem__functor3.html" title="volatile_mem_functor3 wraps volatile methods with 3 argument(s).">volatile_mem_functor3</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1volatile__mem__functor3.html#a39944451f3bb1538828e45b66f082ea0" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="ab525bf6e0a4057a4f3f8f98ff6c1bd74"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab525bf6e0a4057a4f3f8f98ff6c1bd74">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1volatile__mem__functor3.html">sigc::volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a39944451f3bb1538828e45b66f082ea0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a39944451f3bb1538828e45b66f082ea0">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1volatile__mem__functor3.html">sigc::volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000149">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="acf6a8aebcf4de461e03e9b994a807362"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#acf6a8aebcf4de461e03e9b994a807362">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor3.html#aadf62624c12ef82ade8114184f0882c9">function_type</a> <a class="el" href="classsigc_1_1volatile__mem__functor3.html">sigc::volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >" name="sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >">
+<area shape="rect" id="node1" title="volatile_mem_functor3 wraps volatile methods with 3 argument(s)." alt="" coords="19,80,189,151"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__volatile__mem__functor3.html" title="bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance." alt="" coords="5,199,203,269"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="34,5,174,32"/>
+</map>
--- /dev/null
+7863ad782ef59ae54b97d0630feec4fb
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1volatile__mem__functor4.html">volatile_mem_functor4</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1volatile__mem__functor4.html">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#a176ab2202482276e79e6d71ff839c31d">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor4.html">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#a697cad0c578cd4ba3e04f6db8a39e283">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor4.html">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#a86a0e482790971e3674b9ba488e10127">operator()</a>(T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor4.html">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#a58491d7fd980863c7abd311624ada052">operator()</a>(T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor4.html">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#a58dd95fa47c02a9ba6340682c7dbbcb0">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor4.html">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#a5ba462855081b617085e59e7566927a7">volatile_mem_functor4</a>()</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor4.html">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#ab86348ff91ed7ce4cadff97c157e4024">volatile_mem_functor4</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor4.html">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1volatile__mem__functor4.html">volatile_mem_functor4</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1volatile__mem__functor4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1volatile__mem__functor4.html" title="volatile_mem_functor4 wraps volatile methods with 4 argument(s).">volatile_mem_functor4</a> wraps volatile methods with 4 argument(s).
+ <a href="classsigc_1_1volatile__mem__functor4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1volatile__mem__functor4__inherit__graph.png" border="0" usemap="#asigc_1_1volatile__mem__functor4_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1volatile__mem__functor4_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_01_4_inherit__map" id="asigc_1_1volatile__mem__functor4_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_01_4_inherit__map">
+<area shape="rect" title="volatile_mem_functor4 wraps volatile methods with 4 argument(s)." alt="" coords="193,5,363,76"/>
+<area shape="rect" href="classsigc_1_1bound__volatile__mem__functor4.html" title="bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance." alt="" coords="411,5,608,76"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,27,145,54"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a697cad0c578cd4ba3e04f6db8a39e283"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#a697cad0c578cd4ba3e04f6db8a39e283">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4) volatile</td></tr>
+<tr class="separator:a697cad0c578cd4ba3e04f6db8a39e283"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a58dd95fa47c02a9ba6340682c7dbbcb0"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#a58dd95fa47c02a9ba6340682c7dbbcb0">result_type</a></td></tr>
+<tr class="separator:a58dd95fa47c02a9ba6340682c7dbbcb0"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a5ba462855081b617085e59e7566927a7"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#a5ba462855081b617085e59e7566927a7">volatile_mem_functor4</a> ()</td></tr>
+<tr class="memdesc:a5ba462855081b617085e59e7566927a7"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1volatile__mem__functor4.html#a5ba462855081b617085e59e7566927a7">More...</a><br /></td></tr>
+<tr class="separator:a5ba462855081b617085e59e7566927a7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab86348ff91ed7ce4cadff97c157e4024"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#ab86348ff91ed7ce4cadff97c157e4024">volatile_mem_functor4</a> (<a class="el" href="classsigc_1_1volatile__mem__functor4.html#a697cad0c578cd4ba3e04f6db8a39e283">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:ab86348ff91ed7ce4cadff97c157e4024"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1volatile__mem__functor4.html" title="volatile_mem_functor4 wraps volatile methods with 4 argument(s).">volatile_mem_functor4</a> object that wraps the passed method. <a href="classsigc_1_1volatile__mem__functor4.html#ab86348ff91ed7ce4cadff97c157e4024">More...</a><br /></td></tr>
+<tr class="separator:ab86348ff91ed7ce4cadff97c157e4024"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a58491d7fd980863c7abd311624ada052"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#a58491d7fd980863c7abd311624ada052">operator()</a> (T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:a58491d7fd980863c7abd311624ada052"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor4.html#a58491d7fd980863c7abd311624ada052">More...</a><br /></td></tr>
+<tr class="separator:a58491d7fd980863c7abd311624ada052"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a86a0e482790971e3674b9ba488e10127"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#a86a0e482790971e3674b9ba488e10127">operator()</a> (T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4) const</td></tr>
+<tr class="memdesc:a86a0e482790971e3674b9ba488e10127"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor4.html#a86a0e482790971e3674b9ba488e10127">More...</a><br /></td></tr>
+<tr class="separator:a86a0e482790971e3674b9ba488e10127"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:a176ab2202482276e79e6d71ff839c31d"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#a697cad0c578cd4ba3e04f6db8a39e283">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#a176ab2202482276e79e6d71ff839c31d">func_ptr_</a></td></tr>
+<tr class="separator:a176ab2202482276e79e6d71ff839c31d"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4><br />
+class sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></h3>
+
+<p><a class="el" href="classsigc_1_1volatile__mem__functor4.html" title="volatile_mem_functor4 wraps volatile methods with 4 argument(s).">volatile_mem_functor4</a> wraps volatile methods with 4 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1volatile__mem__functor4.html" title="volatile_mem_functor4 wraps volatile methods with 4 argument(s).">volatile_mem_functor4</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1volatile__mem__functor4.html#a86a0e482790971e3674b9ba488e10127" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1volatile__mem__functor4.html#a86a0e482790971e3674b9ba488e10127" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1volatile__mem__functor4.html#a86a0e482790971e3674b9ba488e10127" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1volatile__mem__functor4.html#a86a0e482790971e3674b9ba488e10127" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1volatile__mem__functor4.html#a86a0e482790971e3674b9ba488e10127" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a697cad0c578cd4ba3e04f6db8a39e283"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a697cad0c578cd4ba3e04f6db8a39e283">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1volatile__mem__functor4.html">sigc::volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::function_type) (T_arg1, T_arg2, T_arg3, T_arg4) volatile</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a58dd95fa47c02a9ba6340682c7dbbcb0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a58dd95fa47c02a9ba6340682c7dbbcb0">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1volatile__mem__functor4.html">sigc::volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1volatile__mem__functor4.html#a58dd95fa47c02a9ba6340682c7dbbcb0">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a5ba462855081b617085e59e7566927a7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5ba462855081b617085e59e7566927a7">◆ </a></span>volatile_mem_functor4() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor4.html">sigc::volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1volatile__mem__functor4.html">volatile_mem_functor4</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="ab86348ff91ed7ce4cadff97c157e4024"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab86348ff91ed7ce4cadff97c157e4024">◆ </a></span>volatile_mem_functor4() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor4.html">sigc::volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::<a class="el" href="classsigc_1_1volatile__mem__functor4.html">volatile_mem_functor4</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#a697cad0c578cd4ba3e04f6db8a39e283">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1volatile__mem__functor4.html" title="volatile_mem_functor4 wraps volatile methods with 4 argument(s).">volatile_mem_functor4</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1volatile__mem__functor4.html#a86a0e482790971e3674b9ba488e10127" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a58491d7fd980863c7abd311624ada052"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a58491d7fd980863c7abd311624ada052">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1volatile__mem__functor4.html">sigc::volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a86a0e482790971e3674b9ba488e10127"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a86a0e482790971e3674b9ba488e10127">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1volatile__mem__functor4.html">sigc::volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000150">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a176ab2202482276e79e6d71ff839c31d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a176ab2202482276e79e6d71ff839c31d">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor4.html#a697cad0c578cd4ba3e04f6db8a39e283">function_type</a> <a class="el" href="classsigc_1_1volatile__mem__functor4.html">sigc::volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >" name="sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >">
+<area shape="rect" id="node1" title="volatile_mem_functor4 wraps volatile methods with 4 argument(s)." alt="" coords="193,5,363,76"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__volatile__mem__functor4.html" title="bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance." alt="" coords="411,5,608,76"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,27,145,54"/>
+</map>
--- /dev/null
+546a07a18e03fc199e267f5ccbc99672
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1volatile__mem__functor5.html">volatile_mem_functor5</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1volatile__mem__functor5.html">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#a01d38ddf6e713a47199fba85fd5a8092">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor5.html">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#a43ce719034586bbd097c823376c288ef">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor5.html">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#ab6449c487e42fc9810c0f8d5a6cc243f">operator()</a>(T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor5.html">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#a4a4b9b8ce1ce396ed9fa355ed56cf7b2">operator()</a>(T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor5.html">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#ab647ea2e44db475cc2d4bae8be842127">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor5.html">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#abe1011a71cd8e78d248e072fb7d60231">volatile_mem_functor5</a>()</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor5.html">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#a98e43ac4bafb96958bbbf658154794d0">volatile_mem_functor5</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor5.html">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1volatile__mem__functor5.html">volatile_mem_functor5</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1volatile__mem__functor5-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1volatile__mem__functor5.html" title="volatile_mem_functor5 wraps volatile methods with 5 argument(s).">volatile_mem_functor5</a> wraps volatile methods with 5 argument(s).
+ <a href="classsigc_1_1volatile__mem__functor5.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1volatile__mem__functor5__inherit__graph.png" border="0" usemap="#asigc_1_1volatile__mem__functor5_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1volatile__mem__functor5_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_01_4_inherit__map" id="asigc_1_1volatile__mem__functor5_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_01_4_inherit__map">
+<area shape="rect" title="volatile_mem_functor5 wraps volatile methods with 5 argument(s)." alt="" coords="193,5,383,76"/>
+<area shape="rect" href="classsigc_1_1bound__volatile__mem__functor5.html" title="bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance." alt="" coords="431,5,628,76"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,27,145,54"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a43ce719034586bbd097c823376c288ef"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#a43ce719034586bbd097c823376c288ef">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile</td></tr>
+<tr class="separator:a43ce719034586bbd097c823376c288ef"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab647ea2e44db475cc2d4bae8be842127"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#ab647ea2e44db475cc2d4bae8be842127">result_type</a></td></tr>
+<tr class="separator:ab647ea2e44db475cc2d4bae8be842127"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:abe1011a71cd8e78d248e072fb7d60231"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#abe1011a71cd8e78d248e072fb7d60231">volatile_mem_functor5</a> ()</td></tr>
+<tr class="memdesc:abe1011a71cd8e78d248e072fb7d60231"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1volatile__mem__functor5.html#abe1011a71cd8e78d248e072fb7d60231">More...</a><br /></td></tr>
+<tr class="separator:abe1011a71cd8e78d248e072fb7d60231"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a98e43ac4bafb96958bbbf658154794d0"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#a98e43ac4bafb96958bbbf658154794d0">volatile_mem_functor5</a> (<a class="el" href="classsigc_1_1volatile__mem__functor5.html#a43ce719034586bbd097c823376c288ef">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a98e43ac4bafb96958bbbf658154794d0"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1volatile__mem__functor5.html" title="volatile_mem_functor5 wraps volatile methods with 5 argument(s).">volatile_mem_functor5</a> object that wraps the passed method. <a href="classsigc_1_1volatile__mem__functor5.html#a98e43ac4bafb96958bbbf658154794d0">More...</a><br /></td></tr>
+<tr class="separator:a98e43ac4bafb96958bbbf658154794d0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4a4b9b8ce1ce396ed9fa355ed56cf7b2"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#a4a4b9b8ce1ce396ed9fa355ed56cf7b2">operator()</a> (T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:a4a4b9b8ce1ce396ed9fa355ed56cf7b2"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor5.html#a4a4b9b8ce1ce396ed9fa355ed56cf7b2">More...</a><br /></td></tr>
+<tr class="separator:a4a4b9b8ce1ce396ed9fa355ed56cf7b2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab6449c487e42fc9810c0f8d5a6cc243f"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#ab6449c487e42fc9810c0f8d5a6cc243f">operator()</a> (T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5) const</td></tr>
+<tr class="memdesc:ab6449c487e42fc9810c0f8d5a6cc243f"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor5.html#ab6449c487e42fc9810c0f8d5a6cc243f">More...</a><br /></td></tr>
+<tr class="separator:ab6449c487e42fc9810c0f8d5a6cc243f"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:a01d38ddf6e713a47199fba85fd5a8092"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#a43ce719034586bbd097c823376c288ef">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#a01d38ddf6e713a47199fba85fd5a8092">func_ptr_</a></td></tr>
+<tr class="separator:a01d38ddf6e713a47199fba85fd5a8092"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5><br />
+class sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></h3>
+
+<p><a class="el" href="classsigc_1_1volatile__mem__functor5.html" title="volatile_mem_functor5 wraps volatile methods with 5 argument(s).">volatile_mem_functor5</a> wraps volatile methods with 5 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1volatile__mem__functor5.html" title="volatile_mem_functor5 wraps volatile methods with 5 argument(s).">volatile_mem_functor5</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1volatile__mem__functor5.html#ab6449c487e42fc9810c0f8d5a6cc243f" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1volatile__mem__functor5.html#ab6449c487e42fc9810c0f8d5a6cc243f" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1volatile__mem__functor5.html#ab6449c487e42fc9810c0f8d5a6cc243f" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1volatile__mem__functor5.html#ab6449c487e42fc9810c0f8d5a6cc243f" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1volatile__mem__functor5.html#ab6449c487e42fc9810c0f8d5a6cc243f" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1volatile__mem__functor5.html#ab6449c487e42fc9810c0f8d5a6cc243f" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a43ce719034586bbd097c823376c288ef"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a43ce719034586bbd097c823376c288ef">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1volatile__mem__functor5.html">sigc::volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::function_type) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ab647ea2e44db475cc2d4bae8be842127"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab647ea2e44db475cc2d4bae8be842127">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1volatile__mem__functor5.html">sigc::volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1volatile__mem__functor5.html#ab647ea2e44db475cc2d4bae8be842127">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="abe1011a71cd8e78d248e072fb7d60231"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abe1011a71cd8e78d248e072fb7d60231">◆ </a></span>volatile_mem_functor5() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor5.html">sigc::volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1volatile__mem__functor5.html">volatile_mem_functor5</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="a98e43ac4bafb96958bbbf658154794d0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a98e43ac4bafb96958bbbf658154794d0">◆ </a></span>volatile_mem_functor5() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor5.html">sigc::volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::<a class="el" href="classsigc_1_1volatile__mem__functor5.html">volatile_mem_functor5</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#a43ce719034586bbd097c823376c288ef">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1volatile__mem__functor5.html" title="volatile_mem_functor5 wraps volatile methods with 5 argument(s).">volatile_mem_functor5</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1volatile__mem__functor5.html#ab6449c487e42fc9810c0f8d5a6cc243f" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a4a4b9b8ce1ce396ed9fa355ed56cf7b2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4a4b9b8ce1ce396ed9fa355ed56cf7b2">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1volatile__mem__functor5.html">sigc::volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="ab6449c487e42fc9810c0f8d5a6cc243f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab6449c487e42fc9810c0f8d5a6cc243f">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1volatile__mem__functor5.html">sigc::volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000151">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a01d38ddf6e713a47199fba85fd5a8092"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a01d38ddf6e713a47199fba85fd5a8092">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor5.html#a43ce719034586bbd097c823376c288ef">function_type</a> <a class="el" href="classsigc_1_1volatile__mem__functor5.html">sigc::volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >" name="sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >">
+<area shape="rect" id="node1" title="volatile_mem_functor5 wraps volatile methods with 5 argument(s)." alt="" coords="193,5,383,76"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__volatile__mem__functor5.html" title="bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance." alt="" coords="431,5,628,76"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,27,145,54"/>
+</map>
--- /dev/null
+c08a82ce8478ac390f3f02d9d4432266
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1volatile__mem__functor6.html">volatile_mem_functor6</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1volatile__mem__functor6.html">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#aa64e5accf2702a06bffb6ed68fd95022">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor6.html">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#a67b3a13a2f595360ff6f78cb96efe9d1">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor6.html">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#a00320a319413753f756304a8db0fbf51">operator()</a>(T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor6.html">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#a2fdda8079c742fd0366c3fc057ea45e5">operator()</a>(T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor6.html">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#a1ce192c145ec5af4c826ccb2619cf002">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor6.html">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#a782bbd4bff8bd939a008ceb9e0511bae">volatile_mem_functor6</a>()</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor6.html">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#a55c428dacaaff7f5dcd48ec02b53ed60">volatile_mem_functor6</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor6.html">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1volatile__mem__functor6.html">volatile_mem_functor6</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1volatile__mem__functor6-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1volatile__mem__functor6.html" title="volatile_mem_functor6 wraps volatile methods with 6 argument(s).">volatile_mem_functor6</a> wraps volatile methods with 6 argument(s).
+ <a href="classsigc_1_1volatile__mem__functor6.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1volatile__mem__functor6__inherit__graph.png" border="0" usemap="#asigc_1_1volatile__mem__functor6_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1volatile__mem__functor6_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_01_4_inherit__map" id="asigc_1_1volatile__mem__functor6_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_01_4_inherit__map">
+<area shape="rect" title="volatile_mem_functor6 wraps volatile methods with 6 argument(s)." alt="" coords="193,5,372,91"/>
+<area shape="rect" href="classsigc_1_1bound__volatile__mem__functor6.html" title="bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance." alt="" coords="420,5,617,91"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,35,145,61"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a67b3a13a2f595360ff6f78cb96efe9d1"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#a67b3a13a2f595360ff6f78cb96efe9d1">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile</td></tr>
+<tr class="separator:a67b3a13a2f595360ff6f78cb96efe9d1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1ce192c145ec5af4c826ccb2619cf002"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#a1ce192c145ec5af4c826ccb2619cf002">result_type</a></td></tr>
+<tr class="separator:a1ce192c145ec5af4c826ccb2619cf002"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a782bbd4bff8bd939a008ceb9e0511bae"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#a782bbd4bff8bd939a008ceb9e0511bae">volatile_mem_functor6</a> ()</td></tr>
+<tr class="memdesc:a782bbd4bff8bd939a008ceb9e0511bae"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1volatile__mem__functor6.html#a782bbd4bff8bd939a008ceb9e0511bae">More...</a><br /></td></tr>
+<tr class="separator:a782bbd4bff8bd939a008ceb9e0511bae"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a55c428dacaaff7f5dcd48ec02b53ed60"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#a55c428dacaaff7f5dcd48ec02b53ed60">volatile_mem_functor6</a> (<a class="el" href="classsigc_1_1volatile__mem__functor6.html#a67b3a13a2f595360ff6f78cb96efe9d1">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a55c428dacaaff7f5dcd48ec02b53ed60"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1volatile__mem__functor6.html" title="volatile_mem_functor6 wraps volatile methods with 6 argument(s).">volatile_mem_functor6</a> object that wraps the passed method. <a href="classsigc_1_1volatile__mem__functor6.html#a55c428dacaaff7f5dcd48ec02b53ed60">More...</a><br /></td></tr>
+<tr class="separator:a55c428dacaaff7f5dcd48ec02b53ed60"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2fdda8079c742fd0366c3fc057ea45e5"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#a2fdda8079c742fd0366c3fc057ea45e5">operator()</a> (T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:a2fdda8079c742fd0366c3fc057ea45e5"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor6.html#a2fdda8079c742fd0366c3fc057ea45e5">More...</a><br /></td></tr>
+<tr class="separator:a2fdda8079c742fd0366c3fc057ea45e5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a00320a319413753f756304a8db0fbf51"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#a00320a319413753f756304a8db0fbf51">operator()</a> (T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6) const</td></tr>
+<tr class="memdesc:a00320a319413753f756304a8db0fbf51"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor6.html#a00320a319413753f756304a8db0fbf51">More...</a><br /></td></tr>
+<tr class="separator:a00320a319413753f756304a8db0fbf51"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:aa64e5accf2702a06bffb6ed68fd95022"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#a67b3a13a2f595360ff6f78cb96efe9d1">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#aa64e5accf2702a06bffb6ed68fd95022">func_ptr_</a></td></tr>
+<tr class="separator:aa64e5accf2702a06bffb6ed68fd95022"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6><br />
+class sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></h3>
+
+<p><a class="el" href="classsigc_1_1volatile__mem__functor6.html" title="volatile_mem_functor6 wraps volatile methods with 6 argument(s).">volatile_mem_functor6</a> wraps volatile methods with 6 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1volatile__mem__functor6.html" title="volatile_mem_functor6 wraps volatile methods with 6 argument(s).">volatile_mem_functor6</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1volatile__mem__functor6.html#a00320a319413753f756304a8db0fbf51" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1volatile__mem__functor6.html#a00320a319413753f756304a8db0fbf51" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1volatile__mem__functor6.html#a00320a319413753f756304a8db0fbf51" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1volatile__mem__functor6.html#a00320a319413753f756304a8db0fbf51" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1volatile__mem__functor6.html#a00320a319413753f756304a8db0fbf51" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg6</em> Argument type used in the definition of <a class="el" href="classsigc_1_1volatile__mem__functor6.html#a00320a319413753f756304a8db0fbf51" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1volatile__mem__functor6.html#a00320a319413753f756304a8db0fbf51" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a67b3a13a2f595360ff6f78cb96efe9d1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a67b3a13a2f595360ff6f78cb96efe9d1">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1volatile__mem__functor6.html">sigc::volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::function_type) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a1ce192c145ec5af4c826ccb2619cf002"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1ce192c145ec5af4c826ccb2619cf002">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1volatile__mem__functor6.html">sigc::volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1volatile__mem__functor6.html#a1ce192c145ec5af4c826ccb2619cf002">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a782bbd4bff8bd939a008ceb9e0511bae"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a782bbd4bff8bd939a008ceb9e0511bae">◆ </a></span>volatile_mem_functor6() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor6.html">sigc::volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1volatile__mem__functor6.html">volatile_mem_functor6</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="a55c428dacaaff7f5dcd48ec02b53ed60"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a55c428dacaaff7f5dcd48ec02b53ed60">◆ </a></span>volatile_mem_functor6() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor6.html">sigc::volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::<a class="el" href="classsigc_1_1volatile__mem__functor6.html">volatile_mem_functor6</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#a67b3a13a2f595360ff6f78cb96efe9d1">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1volatile__mem__functor6.html" title="volatile_mem_functor6 wraps volatile methods with 6 argument(s).">volatile_mem_functor6</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1volatile__mem__functor6.html#a00320a319413753f756304a8db0fbf51" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a2fdda8079c742fd0366c3fc057ea45e5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2fdda8079c742fd0366c3fc057ea45e5">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1volatile__mem__functor6.html">sigc::volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a00320a319413753f756304a8db0fbf51"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a00320a319413753f756304a8db0fbf51">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1volatile__mem__functor6.html">sigc::volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000152">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="aa64e5accf2702a06bffb6ed68fd95022"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa64e5accf2702a06bffb6ed68fd95022">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor6.html#a67b3a13a2f595360ff6f78cb96efe9d1">function_type</a> <a class="el" href="classsigc_1_1volatile__mem__functor6.html">sigc::volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >" name="sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >">
+<area shape="rect" id="node1" title="volatile_mem_functor6 wraps volatile methods with 6 argument(s)." alt="" coords="193,5,372,91"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__volatile__mem__functor6.html" title="bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance." alt="" coords="420,5,617,91"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,35,145,61"/>
+</map>
--- /dev/null
+3553226735329e24795b5b6ab0db4e70
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1volatile__mem__functor7.html">volatile_mem_functor7</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classsigc_1_1volatile__mem__functor7.html">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#ac74b72d519805a654529347e4c638e6f">func_ptr_</a></td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor7.html">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#a4ee701fd029c3b7f2f3a3af1aef428a0">function_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor7.html">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#ae587c12caf1c68886fbf001b2c8acc03">operator()</a>(T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor7.html">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#a05ed4811582f583a1a1e11b1a8951a21">operator()</a>(T_obj & _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor7.html">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#a4762374376dcb7b11c77372edab78823">result_type</a> typedef</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor7.html">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#a07834a50703bf92aad9bc167fa256d24">volatile_mem_functor7</a>()</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor7.html">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#a809146646d2dd726a385344f455402e4">volatile_mem_functor7</a>(function_type _A_func)</td><td class="entry"><a class="el" href="classsigc_1_1volatile__mem__functor7.html">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Class Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="classsigc_1_1volatile__mem__functor7.html">volatile_mem_functor7</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="classsigc_1_1volatile__mem__functor7-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > Class Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__mem__fun.html">mem_fun()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="classsigc_1_1volatile__mem__functor7.html" title="volatile_mem_functor7 wraps volatile methods with 7 argument(s).">volatile_mem_functor7</a> wraps volatile methods with 7 argument(s).
+ <a href="classsigc_1_1volatile__mem__functor7.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/mem_fun.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="classsigc_1_1volatile__mem__functor7__inherit__graph.png" border="0" usemap="#asigc_1_1volatile__mem__functor7_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1volatile__mem__functor7_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map" id="asigc_1_1volatile__mem__functor7_3_01T__return_00_01T__obj_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_01_4_inherit__map">
+<area shape="rect" title="volatile_mem_functor7 wraps volatile methods with 7 argument(s)." alt="" coords="193,5,372,91"/>
+<area shape="rect" href="classsigc_1_1bound__volatile__mem__functor7.html" title="bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance." alt="" coords="420,5,617,91"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,35,145,61"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a4ee701fd029c3b7f2f3a3af1aef428a0"><td class="memItemLeft" align="right" valign="top">typedef T_return(T_obj::* </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#a4ee701fd029c3b7f2f3a3af1aef428a0">function_type</a>) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile</td></tr>
+<tr class="separator:a4ee701fd029c3b7f2f3a3af1aef428a0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4762374376dcb7b11c77372edab78823"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#a4762374376dcb7b11c77372edab78823">result_type</a></td></tr>
+<tr class="separator:a4762374376dcb7b11c77372edab78823"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a07834a50703bf92aad9bc167fa256d24"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#a07834a50703bf92aad9bc167fa256d24">volatile_mem_functor7</a> ()</td></tr>
+<tr class="memdesc:a07834a50703bf92aad9bc167fa256d24"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="classsigc_1_1volatile__mem__functor7.html#a07834a50703bf92aad9bc167fa256d24">More...</a><br /></td></tr>
+<tr class="separator:a07834a50703bf92aad9bc167fa256d24"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a809146646d2dd726a385344f455402e4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#a809146646d2dd726a385344f455402e4">volatile_mem_functor7</a> (<a class="el" href="classsigc_1_1volatile__mem__functor7.html#a4ee701fd029c3b7f2f3a3af1aef428a0">function_type</a> _A_func)</td></tr>
+<tr class="memdesc:a809146646d2dd726a385344f455402e4"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="classsigc_1_1volatile__mem__functor7.html" title="volatile_mem_functor7 wraps volatile methods with 7 argument(s).">volatile_mem_functor7</a> object that wraps the passed method. <a href="classsigc_1_1volatile__mem__functor7.html#a809146646d2dd726a385344f455402e4">More...</a><br /></td></tr>
+<tr class="separator:a809146646d2dd726a385344f455402e4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a05ed4811582f583a1a1e11b1a8951a21"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#a05ed4811582f583a1a1e11b1a8951a21">operator()</a> (T_obj & _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:a05ed4811582f583a1a1e11b1a8951a21"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor7.html#a05ed4811582f583a1a1e11b1a8951a21">More...</a><br /></td></tr>
+<tr class="separator:a05ed4811582f583a1a1e11b1a8951a21"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae587c12caf1c68886fbf001b2c8acc03"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#ae587c12caf1c68886fbf001b2c8acc03">operator()</a> (T_obj * _A_obj, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > _A_a1, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > _A_a2, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > _A_a3, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > _A_a4, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > _A_a5, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > _A_a6, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > _A_a7) const</td></tr>
+<tr class="memdesc:ae587c12caf1c68886fbf001b2c8acc03"><td class="mdescLeft"> </td><td class="mdescRight">Execute the wrapped method operating on the passed instance. <a href="classsigc_1_1volatile__mem__functor7.html#ae587c12caf1c68886fbf001b2c8acc03">More...</a><br /></td></tr>
+<tr class="separator:ae587c12caf1c68886fbf001b2c8acc03"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:ac74b72d519805a654529347e4c638e6f"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#a4ee701fd029c3b7f2f3a3af1aef428a0">function_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#ac74b72d519805a654529347e4c638e6f">func_ptr_</a></td></tr>
+<tr class="separator:ac74b72d519805a654529347e4c638e6f"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7><br />
+class sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></h3>
+
+<p><a class="el" href="classsigc_1_1volatile__mem__functor7.html" title="volatile_mem_functor7 wraps volatile methods with 7 argument(s).">volatile_mem_functor7</a> wraps volatile methods with 7 argument(s). </p>
+<p>Use the convenience function <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> to create an instance of <a class="el" href="classsigc_1_1volatile__mem__functor7.html" title="volatile_mem_functor7 wraps volatile methods with 7 argument(s).">volatile_mem_functor7</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_arg1</em> Argument type used in the definition of <a class="el" href="classsigc_1_1volatile__mem__functor7.html#ae587c12caf1c68886fbf001b2c8acc03" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg2</em> Argument type used in the definition of <a class="el" href="classsigc_1_1volatile__mem__functor7.html#ae587c12caf1c68886fbf001b2c8acc03" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg3</em> Argument type used in the definition of <a class="el" href="classsigc_1_1volatile__mem__functor7.html#ae587c12caf1c68886fbf001b2c8acc03" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg4</em> Argument type used in the definition of <a class="el" href="classsigc_1_1volatile__mem__functor7.html#ae587c12caf1c68886fbf001b2c8acc03" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg5</em> Argument type used in the definition of <a class="el" href="classsigc_1_1volatile__mem__functor7.html#ae587c12caf1c68886fbf001b2c8acc03" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg6</em> Argument type used in the definition of <a class="el" href="classsigc_1_1volatile__mem__functor7.html#ae587c12caf1c68886fbf001b2c8acc03" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_arg7</em> Argument type used in the definition of <a class="el" href="classsigc_1_1volatile__mem__functor7.html#ae587c12caf1c68886fbf001b2c8acc03" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_return</em> The return type of <a class="el" href="classsigc_1_1volatile__mem__functor7.html#ae587c12caf1c68886fbf001b2c8acc03" title="Execute the wrapped method operating on the passed instance.">operator()()</a>.</li>
+<li><em>T_obj</em> The object type. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a4ee701fd029c3b7f2f3a3af1aef428a0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4ee701fd029c3b7f2f3a3af1aef428a0">◆ </a></span>function_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return(T_obj::* <a class="el" href="classsigc_1_1volatile__mem__functor7.html">sigc::volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::function_type) (T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a4762374376dcb7b11c77372edab78823"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4762374376dcb7b11c77372edab78823">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="classsigc_1_1volatile__mem__functor7.html">sigc::volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1volatile__mem__functor7.html#a4762374376dcb7b11c77372edab78823">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a07834a50703bf92aad9bc167fa256d24"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a07834a50703bf92aad9bc167fa256d24">◆ </a></span>volatile_mem_functor7() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor7.html">sigc::volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1volatile__mem__functor7.html">volatile_mem_functor7</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="a809146646d2dd726a385344f455402e4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a809146646d2dd726a385344f455402e4">◆ </a></span>volatile_mem_functor7() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor7.html">sigc::volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::<a class="el" href="classsigc_1_1volatile__mem__functor7.html">volatile_mem_functor7</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#a4ee701fd029c3b7f2f3a3af1aef428a0">function_type</a> </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="classsigc_1_1volatile__mem__functor7.html" title="volatile_mem_functor7 wraps volatile methods with 7 argument(s).">volatile_mem_functor7</a> object that wraps the passed method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method will be invoked from <a class="el" href="classsigc_1_1volatile__mem__functor7.html#ae587c12caf1c68886fbf001b2c8acc03" title="Execute the wrapped method operating on the passed instance.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a05ed4811582f583a1a1e11b1a8951a21"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a05ed4811582f583a1a1e11b1a8951a21">◆ </a></span>operator()() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1volatile__mem__functor7.html">sigc::volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > </td>
+ <td class="paramname"><em>_A_a7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a7</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<a id="ae587c12caf1c68886fbf001b2c8acc03"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae587c12caf1c68886fbf001b2c8acc03">◆ </a></span>operator()() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="classsigc_1_1volatile__mem__functor7.html">sigc::volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg1 > </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg2 > </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg3 > </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg4 > </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg5 > </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg6 > </td>
+ <td class="paramname"><em>_A_a6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_arg7 > </td>
+ <td class="paramname"><em>_A_a7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Execute the wrapped method operating on the passed instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000153">Deprecated:</a></b></dt><dd>Please use the constructor that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to instance the method should operate on. </td></tr>
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the method. </td></tr>
+ <tr><td class="paramname">_A_a7</td><td>Argument to be passed on to the method. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the method invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="ac74b72d519805a654529347e4c638e6f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac74b72d519805a654529347e4c638e6f">◆ </a></span>func_ptr_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor7.html#a4ee701fd029c3b7f2f3a3af1aef428a0">function_type</a> <a class="el" href="classsigc_1_1volatile__mem__functor7.html">sigc::volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::func_ptr_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >" name="sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >">
+<area shape="rect" id="node1" title="volatile_mem_functor7 wraps volatile methods with 7 argument(s)." alt="" coords="193,5,372,91"/>
+<area shape="rect" id="node3" href="$classsigc_1_1bound__volatile__mem__functor7.html" title="bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance." alt="" coords="420,5,617,91"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,35,145,61"/>
+</map>
--- /dev/null
+7f9072fca4229af261fdb0b1d4fddc31
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Deprecated List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="PageDoc"><div class="header">
+ <div class="headertitle">
+<div class="title">Deprecated List </div> </div>
+</div><!--header-->
+<div class="contents">
+<div class="textblock"><dl class="reflist">
+<dt>Member <a class="el" href="classsigc_1_1bound__const__mem__functor0.html#a67756fc7a32eb42309a1d55aea2eeb19">sigc::bound_const_mem_functor0< T_return, T_obj >::bound_const_mem_functor0</a> (const T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000170"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__const__mem__functor1.html#aca80f40c27a3346521ffee81ba79da77">sigc::bound_const_mem_functor1< T_return, T_obj, T_arg1 >::bound_const_mem_functor1</a> (const T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000171"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__const__mem__functor2.html#a6732b8f5b308ff8ff1adea9e3734f4bf">sigc::bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >::bound_const_mem_functor2</a> (const T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000172"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__const__mem__functor3.html#ae63bd158d8ce2571038d4f6382a7bc51">sigc::bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::bound_const_mem_functor3</a> (const T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000173"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a1d441ea8caf2d2ff8cfca414f259b657">sigc::bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::bound_const_mem_functor4</a> (const T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000174"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a9e80ad7a6b586eb1d0cc0a4afc9ea1d4">sigc::bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::bound_const_mem_functor5</a> (const T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000175"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a4c6a29813f84239bfc224e36d3ada58c">sigc::bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::bound_const_mem_functor6</a> (const T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000176"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__const__mem__functor7.html#a3353dd997ced3fc00f44ee2b8ccb0063">sigc::bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::bound_const_mem_functor7</a> (const T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000177"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html#a364e1b19994e41acf1d99d27ffca8924">sigc::bound_const_volatile_mem_functor0< T_return, T_obj >::bound_const_volatile_mem_functor0</a> (const T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000186"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html#ac99241e0e7ba52e295f6176c03cdd741">sigc::bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 >::bound_const_volatile_mem_functor1</a> (const T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000187"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a1b629cd2ff30fcaeb035136e190c3f4d">sigc::bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >::bound_const_volatile_mem_functor2</a> (const T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000188"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#a7c5661cbb3554624e50c62789f339aaf">sigc::bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::bound_const_volatile_mem_functor3</a> (const T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000189"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#a97b15b931ba6db1852011d252dd3d5f0">sigc::bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::bound_const_volatile_mem_functor4</a> (const T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000190"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#acc05a40bf47bd943c5d822b354a80ae9">sigc::bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::bound_const_volatile_mem_functor5</a> (const T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000191"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#ae07e825b1d3ee4fa7d4dd45eb7f2fbad">sigc::bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::bound_const_volatile_mem_functor6</a> (const T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000192"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#a6f2635a9548c06f2f5090d75df09fbf1">sigc::bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::bound_const_volatile_mem_functor7</a> (const T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000193"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__mem__functor0.html#a7de90a27f55055cae43df1425cc78415">sigc::bound_mem_functor0< T_return, T_obj >::bound_mem_functor0</a> (T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000162"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__mem__functor1.html#ad13235c20a9171bd24a4f8ae36577448">sigc::bound_mem_functor1< T_return, T_obj, T_arg1 >::bound_mem_functor1</a> (T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000163"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__mem__functor2.html#a48bc9b34469749461813061d17680ca2">sigc::bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >::bound_mem_functor2</a> (T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000164"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__mem__functor3.html#aadbbb586e3ba0c44a25c1f3834c4c438">sigc::bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::bound_mem_functor3</a> (T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000165"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__mem__functor4.html#a15b592122574775dd2c4804617e1e3dd">sigc::bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::bound_mem_functor4</a> (T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000166"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__mem__functor5.html#aaf05ba83268cf4a55f96db281898b406">sigc::bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::bound_mem_functor5</a> (T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000167"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__mem__functor6.html#ab2724a290ceef4f2c279156b606e8c88">sigc::bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::bound_mem_functor6</a> (T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000168"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__mem__functor7.html#a989011ff72d908959d2f0ad346357706">sigc::bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::bound_mem_functor7</a> (T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000169"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html#a5812d3638dc20b9fe37688d31dde8ed8">sigc::bound_volatile_mem_functor0< T_return, T_obj >::bound_volatile_mem_functor0</a> (T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000178"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html#af0b1a108c0080fe202b1d77cae86a7d0">sigc::bound_volatile_mem_functor1< T_return, T_obj, T_arg1 >::bound_volatile_mem_functor1</a> (T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000179"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#af2222c46ab0b47bd59af92ad509ef6fb">sigc::bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >::bound_volatile_mem_functor2</a> (T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000180"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#a21c0be5f093ddcd084cc5ad172ceaf92">sigc::bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::bound_volatile_mem_functor3</a> (T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000181"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#ae2385ee536e72cfbb0d945ba770f2e69">sigc::bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::bound_volatile_mem_functor4</a> (T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000182"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#af5e4db24b5ba51d92746aa3fee080d49">sigc::bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::bound_volatile_mem_functor5</a> (T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000183"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#acb8a7befd300496343cf46d8520db04f">sigc::bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::bound_volatile_mem_functor6</a> (T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000184"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#a18f28191685aa86228328e7016b5c803">sigc::bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::bound_volatile_mem_functor7</a> (T_obj * _A_obj, function_type _A_func)</dt>
+<dd><a class="anchor" id="_deprecated000185"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1const__mem__functor0.html#abcc08c39943577648dac107692e5b34a">sigc::const_mem_functor0< T_return, T_obj >::operator()</a> (const T_obj * _A_obj) const</dt>
+<dd><a class="anchor" id="_deprecated000138"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1const__mem__functor1.html#a9e549ccae24d5a7d1741f17c09db7d5f">sigc::const_mem_functor1< T_return, T_obj, T_arg1 >::operator()</a> (const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1) const</dt>
+<dd><a class="anchor" id="_deprecated000139"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1const__mem__functor2.html#a51c12b33270c350c8988194cb29df590">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >::operator()</a> (const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</dt>
+<dd><a class="anchor" id="_deprecated000140"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1const__mem__functor3.html#a6322fdc9cc492d4f3a2c8482e193540f">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::operator()</a> (const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</dt>
+<dd><a class="anchor" id="_deprecated000141"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1const__mem__functor4.html#a5b178876ca9fbec1fa2339819939a9e7">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::operator()</a> (const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</dt>
+<dd><a class="anchor" id="_deprecated000142"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1const__mem__functor5.html#ae710c03998c58cb8f90ce75a46fab69c">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::operator()</a> (const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</dt>
+<dd><a class="anchor" id="_deprecated000143"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1const__mem__functor6.html#a023fd4cb845234b50c5dee1f4147cde9">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::operator()</a> (const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</dt>
+<dd><a class="anchor" id="_deprecated000144"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1const__mem__functor7.html#a53f19248e5b61460759d7cdbf41ca21b">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::operator()</a> (const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</dt>
+<dd><a class="anchor" id="_deprecated000145"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Class <a class="el" href="structsigc_1_1const__reference__wrapper.html">sigc::const_reference_wrapper< T_type ></a> </dt>
+<dd><a class="anchor" id="_deprecated000203"></a>Use std::ref() or std::cref() instead to create a <a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a03225.html">std::reference_wrapper()</a>. </dd>
+<dt>Member <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#a86005d47b02e980c90d135a636e21674">sigc::const_volatile_mem_functor0< T_return, T_obj >::operator()</a> (const T_obj * _A_obj) const</dt>
+<dd><a class="anchor" id="_deprecated000154"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#a9af06968e1db65f5bd136175e10d250f">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 >::operator()</a> (const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1) const</dt>
+<dd><a class="anchor" id="_deprecated000155"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#a9d024cf10df876df77183e1fb79a52ec">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >::operator()</a> (const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</dt>
+<dd><a class="anchor" id="_deprecated000156"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a47374a80a3a61b69e39478ca9a4a4776">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::operator()</a> (const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</dt>
+<dd><a class="anchor" id="_deprecated000157"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a589c68eddffeb3399838d2af7f5b6d19">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::operator()</a> (const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</dt>
+<dd><a class="anchor" id="_deprecated000158"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a7b1fde7647e7e936b29c97797835ca7b">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::operator()</a> (const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</dt>
+<dd><a class="anchor" id="_deprecated000159"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#adff33012b1d7a20cb39c41c19b1db9a5">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::operator()</a> (const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</dt>
+<dd><a class="anchor" id="_deprecated000160"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a1c9477eed5eef826a4666817aee9ea25">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::operator()</a> (const T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</dt>
+<dd><a class="anchor" id="_deprecated000161"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga0df7af9f32990cc624c4bb60782b4f78">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1) const)</dt>
+<dd><a class="anchor" id="_deprecated000107"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="group__mem__fun.html#gaea5a2ace2699b8d1ffe93585e335548d">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</dt>
+<dd><a class="anchor" id="_deprecated000105"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga7f57ec0156d33b4aa98e259d2e2062db">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)() const)</dt>
+<dd><a class="anchor" id="_deprecated000106"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga02c906c95895c58e39ee301bb1577994">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)</dt>
+<dd><a class="anchor" id="_deprecated000110"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga118b2610268701be95cdc6fddb7bab3b">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) const)</dt>
+<dd><a class="anchor" id="_deprecated000108"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#gaeb6bd4518e0f0c524dba13a6cbb2e319">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) const)</dt>
+<dd><a class="anchor" id="_deprecated000109"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="group__mem__fun.html#ga7f57ec0156d33b4aa98e259d2e2062db">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)())</dt>
+<dd><a class="anchor" id="_deprecated000098"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="group__mem__fun.html#ga3e3841c4844715d2f2d832ed506f028f">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</dt>
+<dd><a class="anchor" id="_deprecated000104"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="group__mem__fun.html#gab138ae1a340be983166b69872826b37d">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</dt>
+<dd><a class="anchor" id="_deprecated000103"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="group__mem__fun.html#ga02c906c95895c58e39ee301bb1577994">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</dt>
+<dd><a class="anchor" id="_deprecated000102"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="group__mem__fun.html#gaeb6bd4518e0f0c524dba13a6cbb2e319">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3))</dt>
+<dd><a class="anchor" id="_deprecated000101"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="group__mem__fun.html#ga118b2610268701be95cdc6fddb7bab3b">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2))</dt>
+<dd><a class="anchor" id="_deprecated000100"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="group__mem__fun.html#ga0df7af9f32990cc624c4bb60782b4f78">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1))</dt>
+<dd><a class="anchor" id="_deprecated000099"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#gab138ae1a340be983166b69872826b37d">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)</dt>
+<dd><a class="anchor" id="_deprecated000127"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#gab138ae1a340be983166b69872826b37d">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)</dt>
+<dd><a class="anchor" id="_deprecated000111"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga3e3841c4844715d2f2d832ed506f028f">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)</dt>
+<dd><a class="anchor" id="_deprecated000112"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#gaea5a2ace2699b8d1ffe93585e335548d">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)</dt>
+<dd><a class="anchor" id="_deprecated000113"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga7f57ec0156d33b4aa98e259d2e2062db">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)() volatile)</dt>
+<dd><a class="anchor" id="_deprecated000114"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga0df7af9f32990cc624c4bb60782b4f78">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1) volatile)</dt>
+<dd><a class="anchor" id="_deprecated000115"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga118b2610268701be95cdc6fddb7bab3b">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) volatile)</dt>
+<dd><a class="anchor" id="_deprecated000116"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#gaeb6bd4518e0f0c524dba13a6cbb2e319">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) volatile)</dt>
+<dd><a class="anchor" id="_deprecated000117"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga02c906c95895c58e39ee301bb1577994">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)</dt>
+<dd><a class="anchor" id="_deprecated000118"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#gab138ae1a340be983166b69872826b37d">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)</dt>
+<dd><a class="anchor" id="_deprecated000119"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga3e3841c4844715d2f2d832ed506f028f">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)</dt>
+<dd><a class="anchor" id="_deprecated000120"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#gaea5a2ace2699b8d1ffe93585e335548d">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)</dt>
+<dd><a class="anchor" id="_deprecated000121"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga7f57ec0156d33b4aa98e259d2e2062db">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)() const volatile)</dt>
+<dd><a class="anchor" id="_deprecated000122"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga0df7af9f32990cc624c4bb60782b4f78">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1) const volatile)</dt>
+<dd><a class="anchor" id="_deprecated000123"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#gaea5a2ace2699b8d1ffe93585e335548d">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)</dt>
+<dd><a class="anchor" id="_deprecated000129"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga3e3841c4844715d2f2d832ed506f028f">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)</dt>
+<dd><a class="anchor" id="_deprecated000128"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga02c906c95895c58e39ee301bb1577994">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)</dt>
+<dd><a class="anchor" id="_deprecated000126"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#gaeb6bd4518e0f0c524dba13a6cbb2e319">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) const volatile)</dt>
+<dd><a class="anchor" id="_deprecated000125"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga118b2610268701be95cdc6fddb7bab3b">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) const volatile)</dt>
+<dd><a class="anchor" id="_deprecated000124"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#gae03d0b73b85e85d2ad8bc43b19b855e3">sigc::mem_fun0</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)() const)</dt>
+<dd><a class="anchor" id="_deprecated000074"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#gae03d0b73b85e85d2ad8bc43b19b855e3">sigc::mem_fun0</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)() volatile)</dt>
+<dd><a class="anchor" id="_deprecated000082"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#gae03d0b73b85e85d2ad8bc43b19b855e3">sigc::mem_fun0</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)() const volatile)</dt>
+<dd><a class="anchor" id="_deprecated000090"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="group__mem__fun.html#gae03d0b73b85e85d2ad8bc43b19b855e3">sigc::mem_fun0</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)())</dt>
+<dd><a class="anchor" id="_deprecated000066"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga3dd8d2ed97310dbf4fa394999f0be7b7">sigc::mem_fun1</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1) const)</dt>
+<dd><a class="anchor" id="_deprecated000075"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga3dd8d2ed97310dbf4fa394999f0be7b7">sigc::mem_fun1</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1) const volatile)</dt>
+<dd><a class="anchor" id="_deprecated000091"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="group__mem__fun.html#ga3dd8d2ed97310dbf4fa394999f0be7b7">sigc::mem_fun1</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1))</dt>
+<dd><a class="anchor" id="_deprecated000067"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga3dd8d2ed97310dbf4fa394999f0be7b7">sigc::mem_fun1</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1) volatile)</dt>
+<dd><a class="anchor" id="_deprecated000083"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga184da4166c8b5409dc4b98d7bc16dff8">sigc::mem_fun2</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) volatile)</dt>
+<dd><a class="anchor" id="_deprecated000084"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga184da4166c8b5409dc4b98d7bc16dff8">sigc::mem_fun2</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) const volatile)</dt>
+<dd><a class="anchor" id="_deprecated000092"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="group__mem__fun.html#ga184da4166c8b5409dc4b98d7bc16dff8">sigc::mem_fun2</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2))</dt>
+<dd><a class="anchor" id="_deprecated000068"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga184da4166c8b5409dc4b98d7bc16dff8">sigc::mem_fun2</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) const)</dt>
+<dd><a class="anchor" id="_deprecated000076"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga4f2fdbf02e8cac9492326a4a8ffdd012">sigc::mem_fun3</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) volatile)</dt>
+<dd><a class="anchor" id="_deprecated000085"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga4f2fdbf02e8cac9492326a4a8ffdd012">sigc::mem_fun3</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) const volatile)</dt>
+<dd><a class="anchor" id="_deprecated000093"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="group__mem__fun.html#ga4f2fdbf02e8cac9492326a4a8ffdd012">sigc::mem_fun3</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3))</dt>
+<dd><a class="anchor" id="_deprecated000069"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga4f2fdbf02e8cac9492326a4a8ffdd012">sigc::mem_fun3</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) const)</dt>
+<dd><a class="anchor" id="_deprecated000077"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="group__mem__fun.html#ga94a2525ef116e16598b81b853544a170">sigc::mem_fun4</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</dt>
+<dd><a class="anchor" id="_deprecated000070"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga94a2525ef116e16598b81b853544a170">sigc::mem_fun4</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)</dt>
+<dd><a class="anchor" id="_deprecated000078"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga94a2525ef116e16598b81b853544a170">sigc::mem_fun4</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)</dt>
+<dd><a class="anchor" id="_deprecated000094"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga94a2525ef116e16598b81b853544a170">sigc::mem_fun4</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)</dt>
+<dd><a class="anchor" id="_deprecated000086"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#gaf060fe3a2be4ff7c0f50aef54b4dc8bf">sigc::mem_fun5</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)</dt>
+<dd><a class="anchor" id="_deprecated000079"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="group__mem__fun.html#gaf060fe3a2be4ff7c0f50aef54b4dc8bf">sigc::mem_fun5</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</dt>
+<dd><a class="anchor" id="_deprecated000071"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#gaf060fe3a2be4ff7c0f50aef54b4dc8bf">sigc::mem_fun5</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)</dt>
+<dd><a class="anchor" id="_deprecated000095"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#gaf060fe3a2be4ff7c0f50aef54b4dc8bf">sigc::mem_fun5</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)</dt>
+<dd><a class="anchor" id="_deprecated000087"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="group__mem__fun.html#gac0a6242da9bf96642f25c1363dfef383">sigc::mem_fun6</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</dt>
+<dd><a class="anchor" id="_deprecated000072"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#gac0a6242da9bf96642f25c1363dfef383">sigc::mem_fun6</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)</dt>
+<dd><a class="anchor" id="_deprecated000096"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#gac0a6242da9bf96642f25c1363dfef383">sigc::mem_fun6</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)</dt>
+<dd><a class="anchor" id="_deprecated000080"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#gac0a6242da9bf96642f25c1363dfef383">sigc::mem_fun6</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)</dt>
+<dd><a class="anchor" id="_deprecated000088"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="group__mem__fun.html#ga9899534bc8eb78c227d895b396710091">sigc::mem_fun7</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</dt>
+<dd><a class="anchor" id="_deprecated000073"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga9899534bc8eb78c227d895b396710091">sigc::mem_fun7</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)</dt>
+<dd><a class="anchor" id="_deprecated000097"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga9899534bc8eb78c227d895b396710091">sigc::mem_fun7</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)</dt>
+<dd><a class="anchor" id="_deprecated000081"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#ga9899534bc8eb78c227d895b396710091">sigc::mem_fun7</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)</dt>
+<dd><a class="anchor" id="_deprecated000089"></a>Please use the version that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1mem__functor0.html#a0a8b70a8f59ddbdc3f1a9892c634bf48">sigc::mem_functor0< T_return, T_obj >::operator()</a> (T_obj * _A_obj) const</dt>
+<dd><a class="anchor" id="_deprecated000130"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1mem__functor1.html#a11fa461ba0bbddc9e5a7dd687e90591b">sigc::mem_functor1< T_return, T_obj, T_arg1 >::operator()</a> (T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1) const</dt>
+<dd><a class="anchor" id="_deprecated000131"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1mem__functor2.html#ad5d0f74803537d1ed8b9678ac2da57d5">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 >::operator()</a> (T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</dt>
+<dd><a class="anchor" id="_deprecated000132"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1mem__functor3.html#ae7496f451661d60b287d528a7cfcaf82">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::operator()</a> (T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</dt>
+<dd><a class="anchor" id="_deprecated000133"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1mem__functor4.html#aef140dac7b4876793fac8a006aad0a62">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::operator()</a> (T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</dt>
+<dd><a class="anchor" id="_deprecated000134"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1mem__functor5.html#a7ad7a4d81470125047755dfa8509c6dc">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::operator()</a> (T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</dt>
+<dd><a class="anchor" id="_deprecated000135"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1mem__functor6.html#afc40dbe8ea11726018dfa7c1ca435f3d">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::operator()</a> (T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</dt>
+<dd><a class="anchor" id="_deprecated000136"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1mem__functor7.html#ab95293e358caf96b5dbf123f024eed8d">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::operator()</a> (T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</dt>
+<dd><a class="anchor" id="_deprecated000137"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#a48e982c74c057b5630246ba436524041">sigc::ref</a> (T_type & v)</dt>
+<dd><a class="anchor" id="_deprecated000204"></a>Use std::ref() or std::cref() instead. </dd>
+<dt>Member <a class="el" href="namespacesigc.html#a670882bd3fa5890b464871ac515aaba9">sigc::ref</a> (const T_type & v)</dt>
+<dd><a class="anchor" id="_deprecated000205"></a>Use std::ref() or std::cref() instead. </dd>
+<dt>Class <a class="el" href="structsigc_1_1reference__wrapper.html">sigc::reference_wrapper< T_type ></a> </dt>
+<dd><a class="anchor" id="_deprecated000202"></a>Use std::ref() or std::cref() instead to create a <a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a03225.html">std::reference_wrapper()</a>. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal0.html#abdae39f9a7abd6133c03d65224c227d6">sigc::signal0< T_return, T_accumulator >::emit_reverse</a> () const</dt>
+<dd><a class="anchor" id="_deprecated000033"></a>This is apparently not useful, but please let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal0.html#a2dd3042c0681542ed6f2de5840f713a1">sigc::signal0< T_return, T_accumulator >::operator()</a> () const</dt>
+<dd><a class="anchor" id="_deprecated000034"></a>This is apparently not useful, but let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal0.html#a5576113ddfd6b92a96f86072262307f9">sigc::signal0< T_return, T_accumulator >::slots</a> ()</dt>
+<dd><a class="anchor" id="_deprecated000035"></a>This is apparently not useful, but please let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal0.html#a73523d71edd7fb4294324e9561db6f3c">sigc::signal0< T_return, T_accumulator >::slots</a> () const</dt>
+<dd><a class="anchor" id="_deprecated000036"></a>This is apparently not useful, but please let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal1.html#a449fc940ae822c4b6ea9282b9b292015">sigc::signal1< T_return, T_arg1, T_accumulator >::emit_reverse</a> (type_trait_take_t< T_arg1 > _A_a1) const</dt>
+<dd><a class="anchor" id="_deprecated000037"></a>This is apparently not useful, but please let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal1.html#a828907c11f5c18d9522e5d5139484620">sigc::signal1< T_return, T_arg1, T_accumulator >::operator()</a> (type_trait_take_t< T_arg1 > _A_a1) const</dt>
+<dd><a class="anchor" id="_deprecated000038"></a>This is apparently not useful, but let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal1.html#a7653b68e6a3b8445de91f89060bf2600">sigc::signal1< T_return, T_arg1, T_accumulator >::slots</a> ()</dt>
+<dd><a class="anchor" id="_deprecated000039"></a>This is apparently not useful, but please let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal1.html#a7777660b21fef2a6941c7dff23964604">sigc::signal1< T_return, T_arg1, T_accumulator >::slots</a> () const</dt>
+<dd><a class="anchor" id="_deprecated000040"></a>This is apparently not useful, but please let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal2.html#ad2d5f3169ba147de8d43fde9e93bac98">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator >::emit_reverse</a> (type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</dt>
+<dd><a class="anchor" id="_deprecated000041"></a>This is apparently not useful, but please let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal2.html#ac8b73c0624273b8dae819255961ea6a3">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator >::operator()</a> (type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</dt>
+<dd><a class="anchor" id="_deprecated000042"></a>This is apparently not useful, but let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal2.html#ac28b0205aa1e60cc5ce062d4d8545323">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator >::slots</a> ()</dt>
+<dd><a class="anchor" id="_deprecated000043"></a>This is apparently not useful, but please let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal2.html#aa6be4804147afd56657abf5b4cf8ce3d">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator >::slots</a> () const</dt>
+<dd><a class="anchor" id="_deprecated000044"></a>This is apparently not useful, but please let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal3.html#a97ff4f22c97920a81e3f27aa5d39ba99">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::emit_reverse</a> (type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</dt>
+<dd><a class="anchor" id="_deprecated000045"></a>This is apparently not useful, but please let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal3.html#aa7ae5338d6a883a28c61ff202e43547f">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::operator()</a> (type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</dt>
+<dd><a class="anchor" id="_deprecated000046"></a>This is apparently not useful, but let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal3.html#a742eb282312187bf8ee6992df1114781">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::slots</a> () const</dt>
+<dd><a class="anchor" id="_deprecated000048"></a>This is apparently not useful, but please let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal3.html#ab9606b708078956a758b81503f956bee">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::slots</a> ()</dt>
+<dd><a class="anchor" id="_deprecated000047"></a>This is apparently not useful, but please let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal4.html#a0aaf27875cdb8a0ae381372d98871ae1">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::emit_reverse</a> (type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</dt>
+<dd><a class="anchor" id="_deprecated000049"></a>This is apparently not useful, but please let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal4.html#a8523a4d47c3a6469fcc50da9977afdb8">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::operator()</a> (type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</dt>
+<dd><a class="anchor" id="_deprecated000050"></a>This is apparently not useful, but let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal4.html#ae490f1a6802c40a4c3b12e1580520c88">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::slots</a> ()</dt>
+<dd><a class="anchor" id="_deprecated000051"></a>This is apparently not useful, but please let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal4.html#a35f2cebe3804d3e04d3253b7cc8d2a72">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::slots</a> () const</dt>
+<dd><a class="anchor" id="_deprecated000052"></a>This is apparently not useful, but please let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal5.html#aa6d2e202263e3879f0d3949612d7fcdf">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::emit_reverse</a> (type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</dt>
+<dd><a class="anchor" id="_deprecated000053"></a>This is apparently not useful, but please let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal5.html#a7a5bb7b92f49e99354caf50bfef16907">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::operator()</a> (type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</dt>
+<dd><a class="anchor" id="_deprecated000054"></a>This is apparently not useful, but let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal5.html#a32af276c9c56abbb0386f54262b40be5">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::slots</a> () const</dt>
+<dd><a class="anchor" id="_deprecated000056"></a>This is apparently not useful, but please let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal5.html#ad6a4ae2a214d8710be6e36bb425587fc">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::slots</a> ()</dt>
+<dd><a class="anchor" id="_deprecated000055"></a>This is apparently not useful, but please let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal6.html#a2e8b355902f0646fb34b52b495123167">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::emit_reverse</a> (type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</dt>
+<dd><a class="anchor" id="_deprecated000057"></a>This is apparently not useful, but please let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal6.html#affec011fd6e9605f10e50fdd4db424d8">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::operator()</a> (type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</dt>
+<dd><a class="anchor" id="_deprecated000058"></a>This is apparently not useful, but let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal6.html#ac66109f683ae86898ae10109a80b28a4">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::slots</a> () const</dt>
+<dd><a class="anchor" id="_deprecated000060"></a>This is apparently not useful, but please let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal6.html#af44115a7bfa4586fc5312259a1df9567">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::slots</a> ()</dt>
+<dd><a class="anchor" id="_deprecated000059"></a>This is apparently not useful, but please let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal7.html#a192581feb2dbcfc9c56692e72e91e9a8">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::emit_reverse</a> (type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</dt>
+<dd><a class="anchor" id="_deprecated000061"></a>This is apparently not useful, but please let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal7.html#ac6fd43215c8f19082402387359330071">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::operator()</a> (type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</dt>
+<dd><a class="anchor" id="_deprecated000062"></a>This is apparently not useful, but let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal7.html#a68153d9079b4881352113079cd6216f7">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::slots</a> ()</dt>
+<dd><a class="anchor" id="_deprecated000063"></a>This is apparently not useful, but please let us know if you need it. </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal7.html#a42509108239296e424844df2cd330aca">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::slots</a> () const</dt>
+<dd><a class="anchor" id="_deprecated000064"></a>This is apparently not useful, but please let us know if you need it. </dd>
+<dt>Class <a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil ></a> </dt>
+<dd><a class="anchor" id="_deprecated000002"></a>Please use the syntax similar to that used by std::function<>: </dd>
+<dt>Class <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a> </dt>
+<dd><a class="anchor" id="_deprecated000003"></a>Please use the syntax similar to that used by std::function<>: </dd>
+<dt>Class <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a> </dt>
+<dd><a class="anchor" id="_deprecated000004"></a>Please use the syntax similar to that used by std::function<>: </dd>
+<dt>Class <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a> </dt>
+<dd><a class="anchor" id="_deprecated000005"></a>Please use the syntax similar to that used by std::function<>: </dd>
+<dt>Class <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a> </dt>
+<dd><a class="anchor" id="_deprecated000006"></a>Please use the syntax similar to that used by std::function<>: </dd>
+<dt>Class <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a> </dt>
+<dd><a class="anchor" id="_deprecated000007"></a>Please use the syntax similar to that used by std::function<>: </dd>
+<dt>Class <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a> </dt>
+<dd><a class="anchor" id="_deprecated000008"></a>Please use the syntax similar to that used by std::function<>: </dd>
+<dt>Class <a class="el" href="classsigc_1_1signal.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a> </dt>
+<dd><a class="anchor" id="_deprecated000001"></a>Please use the syntax similar to that used by std::function<>: </dd>
+<dt>Class <a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil ></a> </dt>
+<dd><a class="anchor" id="_deprecated000195"></a>Please use the syntax similar to that used by std::function<>: </dd>
+<dt>Class <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a> </dt>
+<dd><a class="anchor" id="_deprecated000196"></a>Please use the syntax similar to that used by std::function<>: </dd>
+<dt>Class <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a> </dt>
+<dd><a class="anchor" id="_deprecated000197"></a>Please use the syntax similar to that used by std::function<>: </dd>
+<dt>Class <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a> </dt>
+<dd><a class="anchor" id="_deprecated000198"></a>Please use the syntax similar to that used by std::function<>: </dd>
+<dt>Class <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a> </dt>
+<dd><a class="anchor" id="_deprecated000199"></a>Please use the syntax similar to that used by std::function<>: </dd>
+<dt>Class <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a> </dt>
+<dd><a class="anchor" id="_deprecated000200"></a>Please use the syntax similar to that used by std::function<>: </dd>
+<dt>Class <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a> </dt>
+<dd><a class="anchor" id="_deprecated000201"></a>Please use the syntax similar to that used by std::function<>: </dd>
+<dt>Class <a class="el" href="classsigc_1_1slot.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a> </dt>
+<dd><a class="anchor" id="_deprecated000194"></a>Please use the syntax similar to that used by std::function<>: </dd>
+<dt>Member <a class="el" href="classsigc_1_1volatile__mem__functor0.html#af627ef410fac7ec5d2ee842d8f89fe51">sigc::volatile_mem_functor0< T_return, T_obj >::operator()</a> (T_obj * _A_obj) const</dt>
+<dd><a class="anchor" id="_deprecated000146"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1volatile__mem__functor1.html#a69185452103c51af81b78e95504eb95c">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 >::operator()</a> (T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1) const</dt>
+<dd><a class="anchor" id="_deprecated000147"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1volatile__mem__functor2.html#ac4c64a4812347e17744e33e5e37775d7">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >::operator()</a> (T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</dt>
+<dd><a class="anchor" id="_deprecated000148"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1volatile__mem__functor3.html#a39944451f3bb1538828e45b66f082ea0">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >::operator()</a> (T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</dt>
+<dd><a class="anchor" id="_deprecated000149"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1volatile__mem__functor4.html#a86a0e482790971e3674b9ba488e10127">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >::operator()</a> (T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</dt>
+<dd><a class="anchor" id="_deprecated000150"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1volatile__mem__functor5.html#ab6449c487e42fc9810c0f8d5a6cc243f">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::operator()</a> (T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</dt>
+<dd><a class="anchor" id="_deprecated000151"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1volatile__mem__functor6.html#a00320a319413753f756304a8db0fbf51">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::operator()</a> (T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</dt>
+<dd><a class="anchor" id="_deprecated000152"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="classsigc_1_1volatile__mem__functor7.html#ae587c12caf1c68886fbf001b2c8acc03">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::operator()</a> (T_obj * _A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</dt>
+<dd><a class="anchor" id="_deprecated000153"></a>Please use the constructor that takes the object by reference instead. </dd>
+<dt>Member <a class="el" href="group__sigcfunctors.html#gadf1ba3cacb09cc5c3c3e399836ec6e50">SIGC_FUNCTORS_DEDUCE_RESULT_TYPE_WITH_DECLTYPE</a> </dt>
+<dd><a class="anchor" id="_deprecated000065"></a>This macro does nothing. The test it activated in libsigc++ versions before 2.6, is now unconditionally activated.</dd>
+</dl>
+</div></div><!-- contents -->
+</div><!-- PageDoc -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc++/adaptors/lambda Directory Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="dir_ffa8fd617c28221f63108bd7d58d97eb.html">sigc++</a></li><li class="navelem"><a class="el" href="dir_7061c03125b177af05ebe54a01c7815e.html">adaptors</a></li><li class="navelem"><a class="el" href="dir_69292b900bf9f32fa1522c0a297aa561.html">lambda</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">lambda Directory Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="files"></a>
+Files</h2></td></tr>
+<tr class="memitem:base_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>base.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:select_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>select.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc++/adaptors Directory Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="dir_ffa8fd617c28221f63108bd7d58d97eb.html">sigc++</a></li><li class="navelem"><a class="el" href="dir_7061c03125b177af05ebe54a01c7815e.html">adaptors</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">adaptors Directory Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="subdirs"></a>
+Directories</h2></td></tr>
+<tr class="memitem:dir_69292b900bf9f32fa1522c0a297aa561"><td class="memItemLeft" align="right" valign="top">directory  </td><td class="memItemRight" valign="bottom"><a class="el" href="dir_69292b900bf9f32fa1522c0a297aa561.html">lambda</a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="files"></a>
+Files</h2></td></tr>
+<tr class="memitem:adaptor__trait_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>adaptor_trait.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:build__gnome_2libsigcplusplus-2_80_2sigc_09_09_2adaptors_2bind_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>bind.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:build__gnome_2libsigcplusplus-2_80_2sigc_09_09_2adaptors_2bind__return_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>bind_return.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:compose_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>compose.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:deduce__result__type_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>deduce_result_type.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:exception__catch_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>exception_catch.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:hide_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>hide.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:retype_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>retype.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:build__gnome_2libsigcplusplus-2_80_2sigc_09_09_2adaptors_2retype__return_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>retype_return.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:track__obj_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>track_obj.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc++ Directory Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="dir_a7a614a8e549e28882ee9909ca095aec.html">sigc++</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc++ Directory Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="subdirs"></a>
+Directories</h2></td></tr>
+<tr class="memitem:dir_d1b074183e01b19b1ce0df6f4868a06f"><td class="memItemLeft" align="right" valign="top">directory  </td><td class="memItemRight" valign="bottom"><a class="el" href="dir_d1b074183e01b19b1ce0df6f4868a06f.html">adaptors</a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:dir_e7ee533ee50f0002bd12390b80ea971b"><td class="memItemLeft" align="right" valign="top">directory  </td><td class="memItemRight" valign="bottom"><a class="el" href="dir_e7ee533ee50f0002bd12390b80ea971b.html">functors</a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="files"></a>
+Files</h2></td></tr>
+<tr class="memitem:gnome_2libsigcplusplus-2_80_2sigc_09_09_2bind_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>bind.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gnome_2libsigcplusplus-2_80_2sigc_09_09_2bind__return_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>bind_return.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:connection_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>connection.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:reference__wrapper_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>reference_wrapper.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gnome_2libsigcplusplus-2_80_2sigc_09_09_2retype__return_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>retype_return.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:sigc_09_09_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>sigc++.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:signal__base_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>signal_base.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gnome_2libsigcplusplus-2_80_2sigc_09_09_2slot_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>slot.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:trackable_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>trackable.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:type__traits_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>type_traits.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:visit__each_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>visit_each.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc++/adaptors Directory Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="dir_a7a614a8e549e28882ee9909ca095aec.html">sigc++</a></li><li class="navelem"><a class="el" href="dir_d1b074183e01b19b1ce0df6f4868a06f.html">adaptors</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">adaptors Directory Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="files"></a>
+Files</h2></td></tr>
+<tr class="memitem:adaptors_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>adaptors.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:bound__argument_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>bound_argument.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc++/functors Directory Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="dir_ffa8fd617c28221f63108bd7d58d97eb.html">sigc++</a></li><li class="navelem"><a class="el" href="dir_e610d0fd7d8d422b14c5e759f0ef71be.html">functors</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">functors Directory Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="files"></a>
+Files</h2></td></tr>
+<tr class="memitem:functor__trait_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>functor_trait.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:mem__fun_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>mem_fun.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ptr__fun_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>ptr_fun.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:build__gnome_2libsigcplusplus-2_80_2sigc_09_09_2functors_2slot_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>slot.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc++/functors Directory Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="dir_a7a614a8e549e28882ee9909ca095aec.html">sigc++</a></li><li class="navelem"><a class="el" href="dir_e7ee533ee50f0002bd12390b80ea971b.html">functors</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">functors Directory Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="files"></a>
+Files</h2></td></tr>
+<tr class="memitem:functors_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>functors.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:slot__base_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>slot_base.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc++ Directory Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="dir_ffa8fd617c28221f63108bd7d58d97eb.html">sigc++</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc++ Directory Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="subdirs"></a>
+Directories</h2></td></tr>
+<tr class="memitem:dir_7061c03125b177af05ebe54a01c7815e"><td class="memItemLeft" align="right" valign="top">directory  </td><td class="memItemRight" valign="bottom"><a class="el" href="dir_7061c03125b177af05ebe54a01c7815e.html">adaptors</a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:dir_e610d0fd7d8d422b14c5e759f0ef71be"><td class="memItemLeft" align="right" valign="top">directory  </td><td class="memItemRight" valign="bottom"><a class="el" href="dir_e610d0fd7d8d422b14c5e759f0ef71be.html">functors</a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="files"></a>
+Files</h2></td></tr>
+<tr class="memitem:limit__reference_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>limit_reference.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:signal_8h"><td class="memItemLeft" align="right" valign="top">file  </td><td class="memItemRight" valign="bottom"><b>signal.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+/* GNOME C++ bindings Doxygen style */
+
+/* Use in Doxyfile.in
+ * HTML_EXTRA_STYLESHEET = "$(MMDOCTOOLDIR)/doxygen-extra.css"
+ */
+
+html, body {
+ background: #FFFFFF;
+ color: #222222;
+ margin: 0;
+}
+
+body {
+ font: normal 90%/150% sans-serif;
+ padding: 1.5em;
+ min-width: 28em;
+}
+
+table {
+ font-size: inherit;
+}
+
+img {
+ border-style: none;
+}
+
+address img {
+ vertical-align: middle;
+}
+
+h1 {
+ font-size: 150%;
+ line-height: 120%;
+ text-align: center;
+}
+
+h2 {
+ font-size: 120%;
+}
+
+h3 {
+ font-size: 100%;
+}
+
+h1 + h3 {
+ text-align: center;
+}
+
+.navpath {
+ display: none;
+}
+
+caption {
+ font-weight: bold;
+}
+
+p, dl {
+ margin: 0.75em 0;
+}
+
+.center {
+ text-align: center;
+}
+
+div.qindex {
+ width: 100%;
+ line-height: 140%;
+ background-color: #E8EEF2;
+ border: 1px solid #84B0C7;
+ text-align: center;
+ margin: 0.2em;
+ padding: 0.2em;
+}
+
+a {
+ color: #153788;
+ font-weight: normal;
+ text-decoration: none;
+}
+
+.contents a:visited {
+ color: #1B77C5;
+}
+
+a:hover {
+ text-decoration: underline;
+}
+
+a.el, a.qindex {
+ font-weight: bold;
+}
+
+dl.el {
+ margin-left: -1.5em;
+}
+
+code, .fragment {
+ font-family: monospace, fixed;
+}
+
+pre.fragment, div.fragment {
+ background-color: #EEEEFF;
+ border: 1px solid #AAAAFF;
+ padding: 0.5em;
+ margin: 0.375em 0.75em 0.375em 0.2em;
+}
+
+div.fragment > pre.fragment {
+ border-style: none;
+ padding: 0;
+ margin: 0;
+}
+
+div.line {
+ white-space: pre;
+}
+
+div.ah {
+ background-color: #000000;
+ color: #FFFFFF;
+ font-weight: bold;
+ margin: 0.2em 0;
+}
+
+.indexkey, .indexvalue {
+ background-color: #E8EEF2;
+ border: 1px solid #CCCCCC;
+ margin: 0.2em 0;
+ padding: 0.2em 0.75em;
+}
+
+.indexkey {
+ font-weight: bold;
+}
+.memlist {
+ background-color: #F0F0F0;
+}
+
+span.keyword {
+ color: #008000;
+}
+
+span.keywordtype {
+ color: #604020;
+}
+
+span.keywordflow {
+ color: #E08000;
+}
+
+span.comment {
+ color: #800000;
+}
+
+span.preprocessor {
+ color: #806020;
+}
+
+span.stringliteral {
+ color: #002080;
+}
+
+span.charliteral {
+ color: #008080;
+}
+
+.tiny {
+ font-size: 80%;
+}
+
+hr {
+ height: 0;
+ border: none;
+ border-top: 1px solid #666666;
+}
+
+.mdescLeft, .mdescRight, .memItemLeft, .memItemRight,
+.memTemplItemLeft, .memTemplItemRight, .memTemplParams {
+ background-color: #FAFAFA;
+ border: none;
+ margin: 0.375em;
+ padding: 0.125em 0 0 0.75em;
+}
+
+.mdescLeft, .mdescRight {
+ padding: 0 0.75em 0.375em;
+ color: #555555;
+}
+
+.memItemLeft, .memItemRight, .memTemplParams {
+ border-top: 1px solid #CCCCCC;
+}
+
+.memTemplParams {
+ color: #606060;
+}
+
+.memtemplate {
+ color: #606060;
+ font-size: 90%;
+ font-weight: normal;
+ margin-left: 0.2em;
+}
+
+.memnav {
+ background-color: #E8EEF2;
+ border: 1px solid #84B0C7;
+ text-align: center;
+ margin: 0.2em 1em 0.2em 0;
+ padding: 0.2em;
+}
+
+.memitem {
+ margin: 0.5em 0;
+ padding: 0;
+}
+
+.memname {
+ white-space: nowrap;
+ font-weight: bold;
+ line-height: 120%;
+}
+
+.memproto, .memdoc {
+ border: 1px solid #84B0C7;
+}
+
+.memproto {
+ padding: 0;
+ background-color: #D5E1E8;
+ font-weight: bold;
+ -webkit-border-top-left-radius: 1ex;
+ -webkit-border-top-right-radius: 1ex;
+ -moz-border-radius-topleft: 1ex;
+ -moz-border-radius-topright: 1ex;
+}
+
+.memdoc {
+ padding: 0.2em 0.5em;
+ background-color: #EEF3F5;
+ border-top-width: 0;
+ -webkit-border-bottom-left-radius: 1ex;
+ -webkit-border-bottom-right-radius: 1ex;
+ -moz-border-radius-bottomleft: 1ex;
+ -moz-border-radius-bottomright: 1ex;
+}
+
+.paramkey {
+ text-align: right;
+}
+
+.paramtype {
+ white-space: nowrap;
+}
+
+.paramname {
+ color: #602020;
+ white-space: nowrap;
+}
+
+.paramname em {
+ font-style: normal;
+}
--- /dev/null
+/* The standard CSS for doxygen 1.9.1 */
+
+body, table, div, p, dl {
+ font: 400 14px/22px Roboto,sans-serif;
+}
+
+p.reference, p.definition {
+ font: 400 14px/22px Roboto,sans-serif;
+}
+
+/* @group Heading Levels */
+
+h1.groupheader {
+ font-size: 150%;
+}
+
+.title {
+ font: 400 14px/28px Roboto,sans-serif;
+ font-size: 150%;
+ font-weight: bold;
+ margin: 10px 2px;
+}
+
+h2.groupheader {
+ border-bottom: 1px solid #879ECB;
+ color: #354C7B;
+ font-size: 150%;
+ font-weight: normal;
+ margin-top: 1.75em;
+ padding-top: 8px;
+ padding-bottom: 4px;
+ width: 100%;
+}
+
+h3.groupheader {
+ font-size: 100%;
+}
+
+h1, h2, h3, h4, h5, h6 {
+ -webkit-transition: text-shadow 0.5s linear;
+ -moz-transition: text-shadow 0.5s linear;
+ -ms-transition: text-shadow 0.5s linear;
+ -o-transition: text-shadow 0.5s linear;
+ transition: text-shadow 0.5s linear;
+ margin-right: 15px;
+}
+
+h1.glow, h2.glow, h3.glow, h4.glow, h5.glow, h6.glow {
+ text-shadow: 0 0 15px cyan;
+}
+
+dt {
+ font-weight: bold;
+}
+
+ul.multicol {
+ -moz-column-gap: 1em;
+ -webkit-column-gap: 1em;
+ column-gap: 1em;
+ -moz-column-count: 3;
+ -webkit-column-count: 3;
+ column-count: 3;
+}
+
+p.startli, p.startdd {
+ margin-top: 2px;
+}
+
+th p.starttd, th p.intertd, th p.endtd {
+ font-size: 100%;
+ font-weight: 700;
+}
+
+p.starttd {
+ margin-top: 0px;
+}
+
+p.endli {
+ margin-bottom: 0px;
+}
+
+p.enddd {
+ margin-bottom: 4px;
+}
+
+p.endtd {
+ margin-bottom: 2px;
+}
+
+p.interli {
+}
+
+p.interdd {
+}
+
+p.intertd {
+}
+
+/* @end */
+
+caption {
+ font-weight: bold;
+}
+
+span.legend {
+ font-size: 70%;
+ text-align: center;
+}
+
+h3.version {
+ font-size: 90%;
+ text-align: center;
+}
+
+div.navtab {
+ border-right: 1px solid #A3B4D7;
+ padding-right: 15px;
+ text-align: right;
+ line-height: 110%;
+}
+
+div.navtab table {
+ border-spacing: 0;
+}
+
+td.navtab {
+ padding-right: 6px;
+ padding-left: 6px;
+}
+td.navtabHL {
+ background-image: url('tab_a.png');
+ background-repeat:repeat-x;
+ padding-right: 6px;
+ padding-left: 6px;
+}
+
+td.navtabHL a, td.navtabHL a:visited {
+ color: #fff;
+ text-shadow: 0px 1px 1px rgba(0, 0, 0, 1.0);
+}
+
+a.navtab {
+ font-weight: bold;
+}
+
+div.qindex{
+ text-align: center;
+ width: 100%;
+ line-height: 140%;
+ font-size: 130%;
+ color: #A0A0A0;
+}
+
+dt.alphachar{
+ font-size: 180%;
+ font-weight: bold;
+}
+
+.alphachar a{
+ color: black;
+}
+
+.alphachar a:hover, .alphachar a:visited{
+ text-decoration: none;
+}
+
+.classindex dl {
+ padding: 25px;
+ column-count:1
+}
+
+.classindex dd {
+ display:inline-block;
+ margin-left: 50px;
+ width: 90%;
+ line-height: 1.15em;
+}
+
+.classindex dl.odd {
+ background-color: #F8F9FC;
+}
+
+@media(min-width: 1120px) {
+ .classindex dl {
+ column-count:2
+ }
+}
+
+@media(min-width: 1320px) {
+ .classindex dl {
+ column-count:3
+ }
+}
+
+
+/* @group Link Styling */
+
+a {
+ color: #3D578C;
+ font-weight: normal;
+ text-decoration: none;
+}
+
+.contents a:visited {
+ color: #4665A2;
+}
+
+a:hover {
+ text-decoration: underline;
+}
+
+.contents a.qindexHL:visited {
+ color: #FFFFFF;
+}
+
+a.el {
+ font-weight: bold;
+}
+
+a.elRef {
+}
+
+a.code, a.code:visited, a.line, a.line:visited {
+ color: #4665A2;
+}
+
+a.codeRef, a.codeRef:visited, a.lineRef, a.lineRef:visited {
+ color: #4665A2;
+}
+
+/* @end */
+
+dl.el {
+ margin-left: -1cm;
+}
+
+ul {
+ overflow: hidden; /*Fixed: list item bullets overlap floating elements*/
+}
+
+#side-nav ul {
+ overflow: visible; /* reset ul rule for scroll bar in GENERATE_TREEVIEW window */
+}
+
+#main-nav ul {
+ overflow: visible; /* reset ul rule for the navigation bar drop down lists */
+}
+
+.fragment {
+ text-align: left;
+ direction: ltr;
+ overflow-x: auto; /*Fixed: fragment lines overlap floating elements*/
+ overflow-y: hidden;
+}
+
+pre.fragment {
+ border: 1px solid #C4CFE5;
+ background-color: #FBFCFD;
+ padding: 4px 6px;
+ margin: 4px 8px 4px 2px;
+ overflow: auto;
+ word-wrap: break-word;
+ font-size: 9pt;
+ line-height: 125%;
+ font-family: monospace, fixed;
+ font-size: 105%;
+}
+
+div.fragment {
+ padding: 0 0 1px 0; /*Fixed: last line underline overlap border*/
+ margin: 4px 8px 4px 2px;
+ background-color: #FBFCFD;
+ border: 1px solid #C4CFE5;
+}
+
+div.line {
+ font-family: monospace, fixed;
+ font-size: 13px;
+ min-height: 13px;
+ line-height: 1.0;
+ text-wrap: unrestricted;
+ white-space: -moz-pre-wrap; /* Moz */
+ white-space: -pre-wrap; /* Opera 4-6 */
+ white-space: -o-pre-wrap; /* Opera 7 */
+ white-space: pre-wrap; /* CSS3 */
+ word-wrap: break-word; /* IE 5.5+ */
+ text-indent: -53px;
+ padding-left: 53px;
+ padding-bottom: 0px;
+ margin: 0px;
+ -webkit-transition-property: background-color, box-shadow;
+ -webkit-transition-duration: 0.5s;
+ -moz-transition-property: background-color, box-shadow;
+ -moz-transition-duration: 0.5s;
+ -ms-transition-property: background-color, box-shadow;
+ -ms-transition-duration: 0.5s;
+ -o-transition-property: background-color, box-shadow;
+ -o-transition-duration: 0.5s;
+ transition-property: background-color, box-shadow;
+ transition-duration: 0.5s;
+}
+
+div.line:after {
+ content:"\000A";
+ white-space: pre;
+}
+
+div.line.glow {
+ background-color: cyan;
+ box-shadow: 0 0 10px cyan;
+}
+
+
+span.lineno {
+ padding-right: 4px;
+ text-align: right;
+ border-right: 2px solid #0F0;
+ background-color: #E8E8E8;
+ white-space: pre;
+}
+span.lineno a {
+ background-color: #D8D8D8;
+}
+
+span.lineno a:hover {
+ background-color: #C8C8C8;
+}
+
+.lineno {
+ -webkit-touch-callout: none;
+ -webkit-user-select: none;
+ -khtml-user-select: none;
+ -moz-user-select: none;
+ -ms-user-select: none;
+ user-select: none;
+}
+
+div.ah, span.ah {
+ background-color: black;
+ font-weight: bold;
+ color: #FFFFFF;
+ margin-bottom: 3px;
+ margin-top: 3px;
+ padding: 0.2em;
+ border: solid thin #333;
+ border-radius: 0.5em;
+ -webkit-border-radius: .5em;
+ -moz-border-radius: .5em;
+ box-shadow: 2px 2px 3px #999;
+ -webkit-box-shadow: 2px 2px 3px #999;
+ -moz-box-shadow: rgba(0, 0, 0, 0.15) 2px 2px 2px;
+ background-image: -webkit-gradient(linear, left top, left bottom, from(#eee), to(#000),color-stop(0.3, #444));
+ background-image: -moz-linear-gradient(center top, #eee 0%, #444 40%, #000 110%);
+}
+
+div.classindex ul {
+ list-style: none;
+ padding-left: 0;
+}
+
+div.classindex span.ai {
+ display: inline-block;
+}
+
+div.groupHeader {
+ margin-left: 16px;
+ margin-top: 12px;
+ font-weight: bold;
+}
+
+div.groupText {
+ margin-left: 16px;
+ font-style: italic;
+}
+
+body {
+ background-color: white;
+ color: black;
+ margin: 0;
+}
+
+div.contents {
+ margin-top: 10px;
+ margin-left: 12px;
+ margin-right: 8px;
+}
+
+td.indexkey {
+ background-color: #EBEFF6;
+ font-weight: bold;
+ border: 1px solid #C4CFE5;
+ margin: 2px 0px 2px 0;
+ padding: 2px 10px;
+ white-space: nowrap;
+ vertical-align: top;
+}
+
+td.indexvalue {
+ background-color: #EBEFF6;
+ border: 1px solid #C4CFE5;
+ padding: 2px 10px;
+ margin: 2px 0px;
+}
+
+tr.memlist {
+ background-color: #EEF1F7;
+}
+
+p.formulaDsp {
+ text-align: center;
+}
+
+img.formulaDsp {
+
+}
+
+img.formulaInl, img.inline {
+ vertical-align: middle;
+}
+
+div.center {
+ text-align: center;
+ margin-top: 0px;
+ margin-bottom: 0px;
+ padding: 0px;
+}
+
+div.center img {
+ border: 0px;
+}
+
+address.footer {
+ text-align: right;
+ padding-right: 12px;
+}
+
+img.footer {
+ border: 0px;
+ vertical-align: middle;
+}
+
+/* @group Code Colorization */
+
+span.keyword {
+ color: #008000
+}
+
+span.keywordtype {
+ color: #604020
+}
+
+span.keywordflow {
+ color: #e08000
+}
+
+span.comment {
+ color: #800000
+}
+
+span.preprocessor {
+ color: #806020
+}
+
+span.stringliteral {
+ color: #002080
+}
+
+span.charliteral {
+ color: #008080
+}
+
+span.vhdldigit {
+ color: #ff00ff
+}
+
+span.vhdlchar {
+ color: #000000
+}
+
+span.vhdlkeyword {
+ color: #700070
+}
+
+span.vhdllogic {
+ color: #ff0000
+}
+
+blockquote {
+ background-color: #F7F8FB;
+ border-left: 2px solid #9CAFD4;
+ margin: 0 24px 0 4px;
+ padding: 0 12px 0 16px;
+}
+
+blockquote.DocNodeRTL {
+ border-left: 0;
+ border-right: 2px solid #9CAFD4;
+ margin: 0 4px 0 24px;
+ padding: 0 16px 0 12px;
+}
+
+/* @end */
+
+/*
+.search {
+ color: #003399;
+ font-weight: bold;
+}
+
+form.search {
+ margin-bottom: 0px;
+ margin-top: 0px;
+}
+
+input.search {
+ font-size: 75%;
+ color: #000080;
+ font-weight: normal;
+ background-color: #e8eef2;
+}
+*/
+
+td.tiny {
+ font-size: 75%;
+}
+
+.dirtab {
+ padding: 4px;
+ border-collapse: collapse;
+ border: 1px solid #A3B4D7;
+}
+
+th.dirtab {
+ background: #EBEFF6;
+ font-weight: bold;
+}
+
+hr {
+ height: 0px;
+ border: none;
+ border-top: 1px solid #4A6AAA;
+}
+
+hr.footer {
+ height: 1px;
+}
+
+/* @group Member Descriptions */
+
+table.memberdecls {
+ border-spacing: 0px;
+ padding: 0px;
+}
+
+.memberdecls td, .fieldtable tr {
+ -webkit-transition-property: background-color, box-shadow;
+ -webkit-transition-duration: 0.5s;
+ -moz-transition-property: background-color, box-shadow;
+ -moz-transition-duration: 0.5s;
+ -ms-transition-property: background-color, box-shadow;
+ -ms-transition-duration: 0.5s;
+ -o-transition-property: background-color, box-shadow;
+ -o-transition-duration: 0.5s;
+ transition-property: background-color, box-shadow;
+ transition-duration: 0.5s;
+}
+
+.memberdecls td.glow, .fieldtable tr.glow {
+ background-color: cyan;
+ box-shadow: 0 0 15px cyan;
+}
+
+.mdescLeft, .mdescRight,
+.memItemLeft, .memItemRight,
+.memTemplItemLeft, .memTemplItemRight, .memTemplParams {
+ background-color: #F9FAFC;
+ border: none;
+ margin: 4px;
+ padding: 1px 0 0 8px;
+}
+
+.mdescLeft, .mdescRight {
+ padding: 0px 8px 4px 8px;
+ color: #555;
+}
+
+.memSeparator {
+ border-bottom: 1px solid #DEE4F0;
+ line-height: 1px;
+ margin: 0px;
+ padding: 0px;
+}
+
+.memItemLeft, .memTemplItemLeft {
+ white-space: nowrap;
+}
+
+.memItemRight, .memTemplItemRight {
+ width: 100%;
+}
+
+.memTemplParams {
+ color: #4665A2;
+ white-space: nowrap;
+ font-size: 80%;
+}
+
+/* @end */
+
+/* @group Member Details */
+
+/* Styles for detailed member documentation */
+
+.memtitle {
+ padding: 8px;
+ border-top: 1px solid #A8B8D9;
+ border-left: 1px solid #A8B8D9;
+ border-right: 1px solid #A8B8D9;
+ border-top-right-radius: 4px;
+ border-top-left-radius: 4px;
+ margin-bottom: -1px;
+ background-image: url('nav_f.png');
+ background-repeat: repeat-x;
+ background-color: #E2E8F2;
+ line-height: 1.25;
+ font-weight: 300;
+ float:left;
+}
+
+.permalink
+{
+ font-size: 65%;
+ display: inline-block;
+ vertical-align: middle;
+}
+
+.memtemplate {
+ font-size: 80%;
+ color: #4665A2;
+ font-weight: normal;
+ margin-left: 9px;
+}
+
+.memnav {
+ background-color: #EBEFF6;
+ border: 1px solid #A3B4D7;
+ text-align: center;
+ margin: 2px;
+ margin-right: 15px;
+ padding: 2px;
+}
+
+.mempage {
+ width: 100%;
+}
+
+.memitem {
+ padding: 0;
+ margin-bottom: 10px;
+ margin-right: 5px;
+ -webkit-transition: box-shadow 0.5s linear;
+ -moz-transition: box-shadow 0.5s linear;
+ -ms-transition: box-shadow 0.5s linear;
+ -o-transition: box-shadow 0.5s linear;
+ transition: box-shadow 0.5s linear;
+ display: table !important;
+ width: 100%;
+}
+
+.memitem.glow {
+ box-shadow: 0 0 15px cyan;
+}
+
+.memname {
+ font-weight: 400;
+ margin-left: 6px;
+}
+
+.memname td {
+ vertical-align: bottom;
+}
+
+.memproto, dl.reflist dt {
+ border-top: 1px solid #A8B8D9;
+ border-left: 1px solid #A8B8D9;
+ border-right: 1px solid #A8B8D9;
+ padding: 6px 0px 6px 0px;
+ color: #253555;
+ font-weight: bold;
+ text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9);
+ background-color: #DFE5F1;
+ /* opera specific markup */
+ box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
+ border-top-right-radius: 4px;
+ /* firefox specific markup */
+ -moz-box-shadow: rgba(0, 0, 0, 0.15) 5px 5px 5px;
+ -moz-border-radius-topright: 4px;
+ /* webkit specific markup */
+ -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
+ -webkit-border-top-right-radius: 4px;
+
+}
+
+.overload {
+ font-family: "courier new",courier,monospace;
+ font-size: 65%;
+}
+
+.memdoc, dl.reflist dd {
+ border-bottom: 1px solid #A8B8D9;
+ border-left: 1px solid #A8B8D9;
+ border-right: 1px solid #A8B8D9;
+ padding: 6px 10px 2px 10px;
+ background-color: #FBFCFD;
+ border-top-width: 0;
+ background-image:url('nav_g.png');
+ background-repeat:repeat-x;
+ background-color: #FFFFFF;
+ /* opera specific markup */
+ border-bottom-left-radius: 4px;
+ border-bottom-right-radius: 4px;
+ box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
+ /* firefox specific markup */
+ -moz-border-radius-bottomleft: 4px;
+ -moz-border-radius-bottomright: 4px;
+ -moz-box-shadow: rgba(0, 0, 0, 0.15) 5px 5px 5px;
+ /* webkit specific markup */
+ -webkit-border-bottom-left-radius: 4px;
+ -webkit-border-bottom-right-radius: 4px;
+ -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
+}
+
+dl.reflist dt {
+ padding: 5px;
+}
+
+dl.reflist dd {
+ margin: 0px 0px 10px 0px;
+ padding: 5px;
+}
+
+.paramkey {
+ text-align: right;
+}
+
+.paramtype {
+ white-space: nowrap;
+}
+
+.paramname {
+ color: #602020;
+ white-space: nowrap;
+}
+.paramname em {
+ font-style: normal;
+}
+.paramname code {
+ line-height: 14px;
+}
+
+.params, .retval, .exception, .tparams {
+ margin-left: 0px;
+ padding-left: 0px;
+}
+
+.params .paramname, .retval .paramname, .tparams .paramname, .exception .paramname {
+ font-weight: bold;
+ vertical-align: top;
+}
+
+.params .paramtype, .tparams .paramtype {
+ font-style: italic;
+ vertical-align: top;
+}
+
+.params .paramdir, .tparams .paramdir {
+ font-family: "courier new",courier,monospace;
+ vertical-align: top;
+}
+
+table.mlabels {
+ border-spacing: 0px;
+}
+
+td.mlabels-left {
+ width: 100%;
+ padding: 0px;
+}
+
+td.mlabels-right {
+ vertical-align: bottom;
+ padding: 0px;
+ white-space: nowrap;
+}
+
+span.mlabels {
+ margin-left: 8px;
+}
+
+span.mlabel {
+ background-color: #728DC1;
+ border-top:1px solid #5373B4;
+ border-left:1px solid #5373B4;
+ border-right:1px solid #C4CFE5;
+ border-bottom:1px solid #C4CFE5;
+ text-shadow: none;
+ color: white;
+ margin-right: 4px;
+ padding: 2px 3px;
+ border-radius: 3px;
+ font-size: 7pt;
+ white-space: nowrap;
+ vertical-align: middle;
+}
+
+
+
+/* @end */
+
+/* these are for tree view inside a (index) page */
+
+div.directory {
+ margin: 10px 0px;
+ border-top: 1px solid #9CAFD4;
+ border-bottom: 1px solid #9CAFD4;
+ width: 100%;
+}
+
+.directory table {
+ border-collapse:collapse;
+}
+
+.directory td {
+ margin: 0px;
+ padding: 0px;
+ vertical-align: top;
+}
+
+.directory td.entry {
+ white-space: nowrap;
+ padding-right: 6px;
+ padding-top: 3px;
+}
+
+.directory td.entry a {
+ outline:none;
+}
+
+.directory td.entry a img {
+ border: none;
+}
+
+.directory td.desc {
+ width: 100%;
+ padding-left: 6px;
+ padding-right: 6px;
+ padding-top: 3px;
+ border-left: 1px solid rgba(0,0,0,0.05);
+}
+
+.directory tr.even {
+ padding-left: 6px;
+ background-color: #F7F8FB;
+}
+
+.directory img {
+ vertical-align: -30%;
+}
+
+.directory .levels {
+ white-space: nowrap;
+ width: 100%;
+ text-align: right;
+ font-size: 9pt;
+}
+
+.directory .levels span {
+ cursor: pointer;
+ padding-left: 2px;
+ padding-right: 2px;
+ color: #3D578C;
+}
+
+.arrow {
+ color: #9CAFD4;
+ -webkit-user-select: none;
+ -khtml-user-select: none;
+ -moz-user-select: none;
+ -ms-user-select: none;
+ user-select: none;
+ cursor: pointer;
+ font-size: 80%;
+ display: inline-block;
+ width: 16px;
+ height: 22px;
+}
+
+.icon {
+ font-family: Arial, Helvetica;
+ font-weight: bold;
+ font-size: 12px;
+ height: 14px;
+ width: 16px;
+ display: inline-block;
+ background-color: #728DC1;
+ color: white;
+ text-align: center;
+ border-radius: 4px;
+ margin-left: 2px;
+ margin-right: 2px;
+}
+
+.icona {
+ width: 24px;
+ height: 22px;
+ display: inline-block;
+}
+
+.iconfopen {
+ width: 24px;
+ height: 18px;
+ margin-bottom: 4px;
+ background-image:url('folderopen.png');
+ background-position: 0px -4px;
+ background-repeat: repeat-y;
+ vertical-align:top;
+ display: inline-block;
+}
+
+.iconfclosed {
+ width: 24px;
+ height: 18px;
+ margin-bottom: 4px;
+ background-image:url('folderclosed.png');
+ background-position: 0px -4px;
+ background-repeat: repeat-y;
+ vertical-align:top;
+ display: inline-block;
+}
+
+.icondoc {
+ width: 24px;
+ height: 18px;
+ margin-bottom: 4px;
+ background-image:url('doc.png');
+ background-position: 0px -4px;
+ background-repeat: repeat-y;
+ vertical-align:top;
+ display: inline-block;
+}
+
+table.directory {
+ font: 400 14px Roboto,sans-serif;
+}
+
+/* @end */
+
+div.dynheader {
+ margin-top: 8px;
+ -webkit-touch-callout: none;
+ -webkit-user-select: none;
+ -khtml-user-select: none;
+ -moz-user-select: none;
+ -ms-user-select: none;
+ user-select: none;
+}
+
+address {
+ font-style: normal;
+ color: #2A3D61;
+}
+
+table.doxtable caption {
+ caption-side: top;
+}
+
+table.doxtable {
+ border-collapse:collapse;
+ margin-top: 4px;
+ margin-bottom: 4px;
+}
+
+table.doxtable td, table.doxtable th {
+ border: 1px solid #2D4068;
+ padding: 3px 7px 2px;
+}
+
+table.doxtable th {
+ background-color: #374F7F;
+ color: #FFFFFF;
+ font-size: 110%;
+ padding-bottom: 4px;
+ padding-top: 5px;
+}
+
+table.fieldtable {
+ /*width: 100%;*/
+ margin-bottom: 10px;
+ border: 1px solid #A8B8D9;
+ border-spacing: 0px;
+ -moz-border-radius: 4px;
+ -webkit-border-radius: 4px;
+ border-radius: 4px;
+ -moz-box-shadow: rgba(0, 0, 0, 0.15) 2px 2px 2px;
+ -webkit-box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.15);
+ box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.15);
+}
+
+.fieldtable td, .fieldtable th {
+ padding: 3px 7px 2px;
+}
+
+.fieldtable td.fieldtype, .fieldtable td.fieldname {
+ white-space: nowrap;
+ border-right: 1px solid #A8B8D9;
+ border-bottom: 1px solid #A8B8D9;
+ vertical-align: top;
+}
+
+.fieldtable td.fieldname {
+ padding-top: 3px;
+}
+
+.fieldtable td.fielddoc {
+ border-bottom: 1px solid #A8B8D9;
+ /*width: 100%;*/
+}
+
+.fieldtable td.fielddoc p:first-child {
+ margin-top: 0px;
+}
+
+.fieldtable td.fielddoc p:last-child {
+ margin-bottom: 2px;
+}
+
+.fieldtable tr:last-child td {
+ border-bottom: none;
+}
+
+.fieldtable th {
+ background-image:url('nav_f.png');
+ background-repeat:repeat-x;
+ background-color: #E2E8F2;
+ font-size: 90%;
+ color: #253555;
+ padding-bottom: 4px;
+ padding-top: 5px;
+ text-align:left;
+ font-weight: 400;
+ -moz-border-radius-topleft: 4px;
+ -moz-border-radius-topright: 4px;
+ -webkit-border-top-left-radius: 4px;
+ -webkit-border-top-right-radius: 4px;
+ border-top-left-radius: 4px;
+ border-top-right-radius: 4px;
+ border-bottom: 1px solid #A8B8D9;
+}
+
+
+.tabsearch {
+ top: 0px;
+ left: 10px;
+ height: 36px;
+ background-image: url('tab_b.png');
+ z-index: 101;
+ overflow: hidden;
+ font-size: 13px;
+}
+
+.navpath ul
+{
+ font-size: 11px;
+ background-image:url('tab_b.png');
+ background-repeat:repeat-x;
+ background-position: 0 -5px;
+ height:30px;
+ line-height:30px;
+ color:#8AA0CC;
+ border:solid 1px #C2CDE4;
+ overflow:hidden;
+ margin:0px;
+ padding:0px;
+}
+
+.navpath li
+{
+ list-style-type:none;
+ float:left;
+ padding-left:10px;
+ padding-right:15px;
+ background-image:url('bc_s.png');
+ background-repeat:no-repeat;
+ background-position:right;
+ color:#364D7C;
+}
+
+.navpath li.navelem a
+{
+ height:32px;
+ display:block;
+ text-decoration: none;
+ outline: none;
+ color: #283A5D;
+ font-family: 'Lucida Grande',Geneva,Helvetica,Arial,sans-serif;
+ text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9);
+ text-decoration: none;
+}
+
+.navpath li.navelem a:hover
+{
+ color:#6884BD;
+}
+
+.navpath li.footer
+{
+ list-style-type:none;
+ float:right;
+ padding-left:10px;
+ padding-right:15px;
+ background-image:none;
+ background-repeat:no-repeat;
+ background-position:right;
+ color:#364D7C;
+ font-size: 8pt;
+}
+
+
+div.summary
+{
+ float: right;
+ font-size: 8pt;
+ padding-right: 5px;
+ width: 50%;
+ text-align: right;
+}
+
+div.summary a
+{
+ white-space: nowrap;
+}
+
+table.classindex
+{
+ margin: 10px;
+ white-space: nowrap;
+ margin-left: 3%;
+ margin-right: 3%;
+ width: 94%;
+ border: 0;
+ border-spacing: 0;
+ padding: 0;
+}
+
+div.ingroups
+{
+ font-size: 8pt;
+ width: 50%;
+ text-align: left;
+}
+
+div.ingroups a
+{
+ white-space: nowrap;
+}
+
+div.header
+{
+ background-image:url('nav_h.png');
+ background-repeat:repeat-x;
+ background-color: #F9FAFC;
+ margin: 0px;
+ border-bottom: 1px solid #C4CFE5;
+}
+
+div.headertitle
+{
+ padding: 5px 5px 5px 10px;
+}
+
+.PageDocRTL-title div.headertitle {
+ text-align: right;
+ direction: rtl;
+}
+
+dl {
+ padding: 0 0 0 0;
+}
+
+/* dl.note, dl.warning, dl.attention, dl.pre, dl.post, dl.invariant, dl.deprecated, dl.todo, dl.test, dl.bug, dl.examples */
+dl.section {
+ margin-left: 0px;
+ padding-left: 0px;
+}
+
+dl.section.DocNodeRTL {
+ margin-right: 0px;
+ padding-right: 0px;
+}
+
+dl.note {
+ margin-left: -7px;
+ padding-left: 3px;
+ border-left: 4px solid;
+ border-color: #D0C000;
+}
+
+dl.note.DocNodeRTL {
+ margin-left: 0;
+ padding-left: 0;
+ border-left: 0;
+ margin-right: -7px;
+ padding-right: 3px;
+ border-right: 4px solid;
+ border-color: #D0C000;
+}
+
+dl.warning, dl.attention {
+ margin-left: -7px;
+ padding-left: 3px;
+ border-left: 4px solid;
+ border-color: #FF0000;
+}
+
+dl.warning.DocNodeRTL, dl.attention.DocNodeRTL {
+ margin-left: 0;
+ padding-left: 0;
+ border-left: 0;
+ margin-right: -7px;
+ padding-right: 3px;
+ border-right: 4px solid;
+ border-color: #FF0000;
+}
+
+dl.pre, dl.post, dl.invariant {
+ margin-left: -7px;
+ padding-left: 3px;
+ border-left: 4px solid;
+ border-color: #00D000;
+}
+
+dl.pre.DocNodeRTL, dl.post.DocNodeRTL, dl.invariant.DocNodeRTL {
+ margin-left: 0;
+ padding-left: 0;
+ border-left: 0;
+ margin-right: -7px;
+ padding-right: 3px;
+ border-right: 4px solid;
+ border-color: #00D000;
+}
+
+dl.deprecated {
+ margin-left: -7px;
+ padding-left: 3px;
+ border-left: 4px solid;
+ border-color: #505050;
+}
+
+dl.deprecated.DocNodeRTL {
+ margin-left: 0;
+ padding-left: 0;
+ border-left: 0;
+ margin-right: -7px;
+ padding-right: 3px;
+ border-right: 4px solid;
+ border-color: #505050;
+}
+
+dl.todo {
+ margin-left: -7px;
+ padding-left: 3px;
+ border-left: 4px solid;
+ border-color: #00C0E0;
+}
+
+dl.todo.DocNodeRTL {
+ margin-left: 0;
+ padding-left: 0;
+ border-left: 0;
+ margin-right: -7px;
+ padding-right: 3px;
+ border-right: 4px solid;
+ border-color: #00C0E0;
+}
+
+dl.test {
+ margin-left: -7px;
+ padding-left: 3px;
+ border-left: 4px solid;
+ border-color: #3030E0;
+}
+
+dl.test.DocNodeRTL {
+ margin-left: 0;
+ padding-left: 0;
+ border-left: 0;
+ margin-right: -7px;
+ padding-right: 3px;
+ border-right: 4px solid;
+ border-color: #3030E0;
+}
+
+dl.bug {
+ margin-left: -7px;
+ padding-left: 3px;
+ border-left: 4px solid;
+ border-color: #C08050;
+}
+
+dl.bug.DocNodeRTL {
+ margin-left: 0;
+ padding-left: 0;
+ border-left: 0;
+ margin-right: -7px;
+ padding-right: 3px;
+ border-right: 4px solid;
+ border-color: #C08050;
+}
+
+dl.section dd {
+ margin-bottom: 6px;
+}
+
+
+#projectlogo
+{
+ text-align: center;
+ vertical-align: bottom;
+ border-collapse: separate;
+}
+
+#projectlogo img
+{
+ border: 0px none;
+}
+
+#projectalign
+{
+ vertical-align: middle;
+}
+
+#projectname
+{
+ font: 300% Tahoma, Arial,sans-serif;
+ margin: 0px;
+ padding: 2px 0px;
+}
+
+#projectbrief
+{
+ font: 120% Tahoma, Arial,sans-serif;
+ margin: 0px;
+ padding: 0px;
+}
+
+#projectnumber
+{
+ font: 50% Tahoma, Arial,sans-serif;
+ margin: 0px;
+ padding: 0px;
+}
+
+#titlearea
+{
+ padding: 0px;
+ margin: 0px;
+ width: 100%;
+ border-bottom: 1px solid #5373B4;
+}
+
+.image
+{
+ text-align: center;
+}
+
+.dotgraph
+{
+ text-align: center;
+}
+
+.mscgraph
+{
+ text-align: center;
+}
+
+.plantumlgraph
+{
+ text-align: center;
+}
+
+.diagraph
+{
+ text-align: center;
+}
+
+.caption
+{
+ font-weight: bold;
+}
+
+div.zoom
+{
+ border: 1px solid #90A5CE;
+}
+
+dl.citelist {
+ margin-bottom:50px;
+}
+
+dl.citelist dt {
+ color:#334975;
+ float:left;
+ font-weight:bold;
+ margin-right:10px;
+ padding:5px;
+ text-align:right;
+ width:52px;
+}
+
+dl.citelist dd {
+ margin:2px 0 2px 72px;
+ padding:5px 0;
+}
+
+div.toc {
+ padding: 14px 25px;
+ background-color: #F4F6FA;
+ border: 1px solid #D8DFEE;
+ border-radius: 7px 7px 7px 7px;
+ float: right;
+ height: auto;
+ margin: 0 8px 10px 10px;
+ width: 200px;
+}
+
+.PageDocRTL-title div.toc {
+ float: left !important;
+ text-align: right;
+}
+
+div.toc li {
+ background: url("bdwn.png") no-repeat scroll 0 5px transparent;
+ font: 10px/1.2 Verdana,DejaVu Sans,Geneva,sans-serif;
+ margin-top: 5px;
+ padding-left: 10px;
+ padding-top: 2px;
+}
+
+.PageDocRTL-title div.toc li {
+ background-position-x: right !important;
+ padding-left: 0 !important;
+ padding-right: 10px;
+}
+
+div.toc h3 {
+ font: bold 12px/1.2 Arial,FreeSans,sans-serif;
+ color: #4665A2;
+ border-bottom: 0 none;
+ margin: 0;
+}
+
+div.toc ul {
+ list-style: none outside none;
+ border: medium none;
+ padding: 0px;
+}
+
+div.toc li.level1 {
+ margin-left: 0px;
+}
+
+div.toc li.level2 {
+ margin-left: 15px;
+}
+
+div.toc li.level3 {
+ margin-left: 30px;
+}
+
+div.toc li.level4 {
+ margin-left: 45px;
+}
+
+span.emoji {
+ /* font family used at the site: https://unicode.org/emoji/charts/full-emoji-list.html
+ * font-family: "Noto Color Emoji", "Apple Color Emoji", "Segoe UI Emoji", Times, Symbola, Aegyptus, Code2000, Code2001, Code2002, Musica, serif, LastResort;
+ */
+}
+
+.PageDocRTL-title div.toc li.level1 {
+ margin-left: 0 !important;
+ margin-right: 0;
+}
+
+.PageDocRTL-title div.toc li.level2 {
+ margin-left: 0 !important;
+ margin-right: 15px;
+}
+
+.PageDocRTL-title div.toc li.level3 {
+ margin-left: 0 !important;
+ margin-right: 30px;
+}
+
+.PageDocRTL-title div.toc li.level4 {
+ margin-left: 0 !important;
+ margin-right: 45px;
+}
+
+.inherit_header {
+ font-weight: bold;
+ color: gray;
+ cursor: pointer;
+ -webkit-touch-callout: none;
+ -webkit-user-select: none;
+ -khtml-user-select: none;
+ -moz-user-select: none;
+ -ms-user-select: none;
+ user-select: none;
+}
+
+.inherit_header td {
+ padding: 6px 0px 2px 5px;
+}
+
+.inherit {
+ display: none;
+}
+
+tr.heading h2 {
+ margin-top: 12px;
+ margin-bottom: 4px;
+}
+
+/* tooltip related style info */
+
+.ttc {
+ position: absolute;
+ display: none;
+}
+
+#powerTip {
+ cursor: default;
+ white-space: nowrap;
+ background-color: white;
+ border: 1px solid gray;
+ border-radius: 4px 4px 4px 4px;
+ box-shadow: 1px 1px 7px gray;
+ display: none;
+ font-size: smaller;
+ max-width: 80%;
+ opacity: 0.9;
+ padding: 1ex 1em 1em;
+ position: absolute;
+ z-index: 2147483647;
+}
+
+#powerTip div.ttdoc {
+ color: grey;
+ font-style: italic;
+}
+
+#powerTip div.ttname a {
+ font-weight: bold;
+}
+
+#powerTip div.ttname {
+ font-weight: bold;
+}
+
+#powerTip div.ttdeci {
+ color: #006318;
+}
+
+#powerTip div {
+ margin: 0px;
+ padding: 0px;
+ font: 12px/16px Roboto,sans-serif;
+}
+
+#powerTip:before, #powerTip:after {
+ content: "";
+ position: absolute;
+ margin: 0px;
+}
+
+#powerTip.n:after, #powerTip.n:before,
+#powerTip.s:after, #powerTip.s:before,
+#powerTip.w:after, #powerTip.w:before,
+#powerTip.e:after, #powerTip.e:before,
+#powerTip.ne:after, #powerTip.ne:before,
+#powerTip.se:after, #powerTip.se:before,
+#powerTip.nw:after, #powerTip.nw:before,
+#powerTip.sw:after, #powerTip.sw:before {
+ border: solid transparent;
+ content: " ";
+ height: 0;
+ width: 0;
+ position: absolute;
+}
+
+#powerTip.n:after, #powerTip.s:after,
+#powerTip.w:after, #powerTip.e:after,
+#powerTip.nw:after, #powerTip.ne:after,
+#powerTip.sw:after, #powerTip.se:after {
+ border-color: rgba(255, 255, 255, 0);
+}
+
+#powerTip.n:before, #powerTip.s:before,
+#powerTip.w:before, #powerTip.e:before,
+#powerTip.nw:before, #powerTip.ne:before,
+#powerTip.sw:before, #powerTip.se:before {
+ border-color: rgba(128, 128, 128, 0);
+}
+
+#powerTip.n:after, #powerTip.n:before,
+#powerTip.ne:after, #powerTip.ne:before,
+#powerTip.nw:after, #powerTip.nw:before {
+ top: 100%;
+}
+
+#powerTip.n:after, #powerTip.ne:after, #powerTip.nw:after {
+ border-top-color: #FFFFFF;
+ border-width: 10px;
+ margin: 0px -10px;
+}
+#powerTip.n:before {
+ border-top-color: #808080;
+ border-width: 11px;
+ margin: 0px -11px;
+}
+#powerTip.n:after, #powerTip.n:before {
+ left: 50%;
+}
+
+#powerTip.nw:after, #powerTip.nw:before {
+ right: 14px;
+}
+
+#powerTip.ne:after, #powerTip.ne:before {
+ left: 14px;
+}
+
+#powerTip.s:after, #powerTip.s:before,
+#powerTip.se:after, #powerTip.se:before,
+#powerTip.sw:after, #powerTip.sw:before {
+ bottom: 100%;
+}
+
+#powerTip.s:after, #powerTip.se:after, #powerTip.sw:after {
+ border-bottom-color: #FFFFFF;
+ border-width: 10px;
+ margin: 0px -10px;
+}
+
+#powerTip.s:before, #powerTip.se:before, #powerTip.sw:before {
+ border-bottom-color: #808080;
+ border-width: 11px;
+ margin: 0px -11px;
+}
+
+#powerTip.s:after, #powerTip.s:before {
+ left: 50%;
+}
+
+#powerTip.sw:after, #powerTip.sw:before {
+ right: 14px;
+}
+
+#powerTip.se:after, #powerTip.se:before {
+ left: 14px;
+}
+
+#powerTip.e:after, #powerTip.e:before {
+ left: 100%;
+}
+#powerTip.e:after {
+ border-left-color: #FFFFFF;
+ border-width: 10px;
+ top: 50%;
+ margin-top: -10px;
+}
+#powerTip.e:before {
+ border-left-color: #808080;
+ border-width: 11px;
+ top: 50%;
+ margin-top: -11px;
+}
+
+#powerTip.w:after, #powerTip.w:before {
+ right: 100%;
+}
+#powerTip.w:after {
+ border-right-color: #FFFFFF;
+ border-width: 10px;
+ top: 50%;
+ margin-top: -10px;
+}
+#powerTip.w:before {
+ border-right-color: #808080;
+ border-width: 11px;
+ top: 50%;
+ margin-top: -11px;
+}
+
+@media print
+{
+ #top { display: none; }
+ #side-nav { display: none; }
+ #nav-path { display: none; }
+ body { overflow:visible; }
+ h1, h2, h3, h4, h5, h6 { page-break-after: avoid; }
+ .summary { display: none; }
+ .memitem { page-break-inside: avoid; }
+ #doc-content
+ {
+ margin-left:0 !important;
+ height:auto !important;
+ width:auto !important;
+ overflow:inherit;
+ display:inline;
+ }
+}
+
+/* @group Markdown */
+
+table.markdownTable {
+ border-collapse:collapse;
+ margin-top: 4px;
+ margin-bottom: 4px;
+}
+
+table.markdownTable td, table.markdownTable th {
+ border: 1px solid #2D4068;
+ padding: 3px 7px 2px;
+}
+
+table.markdownTable tr {
+}
+
+th.markdownTableHeadLeft, th.markdownTableHeadRight, th.markdownTableHeadCenter, th.markdownTableHeadNone {
+ background-color: #374F7F;
+ color: #FFFFFF;
+ font-size: 110%;
+ padding-bottom: 4px;
+ padding-top: 5px;
+}
+
+th.markdownTableHeadLeft, td.markdownTableBodyLeft {
+ text-align: left
+}
+
+th.markdownTableHeadRight, td.markdownTableBodyRight {
+ text-align: right
+}
+
+th.markdownTableHeadCenter, td.markdownTableBodyCenter {
+ text-align: center
+}
+
+.DocNodeRTL {
+ text-align: right;
+ direction: rtl;
+}
+
+.DocNodeLTR {
+ text-align: left;
+ direction: ltr;
+}
+
+table.DocNodeRTL {
+ width: auto;
+ margin-right: 0;
+ margin-left: auto;
+}
+
+table.DocNodeLTR {
+ width: auto;
+ margin-right: auto;
+ margin-left: 0;
+}
+
+tt, code, kbd, samp
+{
+ display: inline-block;
+ direction:ltr;
+}
+/* @end */
+
+u {
+ text-decoration: underline;
+}
+
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<svg version="1.1" viewBox="0 0 104 31" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+ <defs>
+ <linearGradient id="a">
+ <stop stop-color="#5373B4" offset="0"/>
+ <stop stop-color="#7C95C6" offset="1"/>
+ </linearGradient>
+ <linearGradient id="d" x1="31.474" x2="31.474" y1="24.821" y2="26.773" gradientUnits="userSpaceOnUse" xlink:href="#a"/>
+ <linearGradient id="c" x1="31.474" x2="31.474" y1="24.821" y2="26.773" gradientTransform="matrix(.6816 0 0 1.0248 72.391 -.91809)" gradientUnits="userSpaceOnUse" xlink:href="#a"/>
+ <linearGradient id="b" x1="56.295" x2="56.295" y1="24.622" y2="26.574" gradientUnits="userSpaceOnUse" xlink:href="#a"/>
+ <linearGradient id="e" x1="49.067" x2="48.956" y1="19.719" y2="9.5227" gradientTransform="matrix(.97968 0 0 1.0207 -.25579 -.25579)" gradientUnits="userSpaceOnUse">
+ <stop stop-color="#C0CCE3" offset="0"/>
+ <stop stop-color="#EEF1F7" offset="1"/>
+ </linearGradient>
+ <filter id="f" x="-.010676" y="-.045304" width="1.0214" height="1.0906" color-interpolation-filters="sRGB">
+ <feGaussianBlur stdDeviation="0.45293203"/>
+ </filter>
+ </defs>
+ <g>
+ <path transform="translate(-2.5759 -27.848)" d="m13.609 32.203v6.8633h-0.05078c-0.40533-0.66867-0.96254-1.1715-1.6719-1.5059-0.69244-0.35193-1.4282-0.52734-2.2051-0.52734-0.96267 0-1.807 0.2027-2.5332 0.60742-0.72622 0.38713-1.3344 0.90556-1.8242 1.5566-0.47289 0.65108-0.83456 1.4092-1.0879 2.2715-0.23644 0.84464-0.35547 1.7236-0.35547 2.6387 0 0.95022 0.11902 1.8643 0.35547 2.7441 0.25333 0.87983 0.615 1.6633 1.0879 2.3496 0.48978 0.66867 1.1065 1.2066 1.8496 1.6113 0.74311 0.38713 1.6044 0.58008 2.584 0.58008 0.86133 0 1.6311-0.15787 2.3066-0.47461 0.69244-0.33434 1.2497-0.87227 1.6719-1.6113h0.05078v1.7422h3.4199v-18.846zm12.875 4.8301c-1.0302 0-1.9596 0.17541-2.7871 0.52734-0.82756 0.33434-1.5358 0.81965-2.127 1.4531-0.59111 0.61588-1.0483 1.3721-1.3691 2.2695-0.32089 0.87983-0.48047 1.866-0.48047 2.957s0.15958 2.0752 0.48047 2.9551c0.32089 0.87983 0.77803 1.6361 1.3691 2.2695 0.59111 0.61588 1.2994 1.0914 2.127 1.4258 0.82756 0.33434 1.7569 0.50195 2.7871 0.50195 1.0302 0 1.9596-0.16762 2.7871-0.50195 0.84444-0.33434 1.5612-0.8099 2.1523-1.4258 0.59111-0.63348 1.0483-1.3897 1.3691-2.2695 0.32089-0.87983 0.48047-1.8641 0.48047-2.9551s-0.15958-2.0772-0.48047-2.957c-0.32089-0.89743-0.77803-1.6536-1.3691-2.2695-0.59111-0.63348-1.3079-1.1188-2.1523-1.4531-0.82756-0.35193-1.7569-0.52734-2.7871-0.52734zm41.715 0c-0.912 0-1.7223 0.18516-2.4316 0.55469-0.69244 0.36953-1.2752 0.87043-1.748 1.5039-0.47289 0.61588-0.83651 1.337-1.0898 2.1641-0.23645 0.80944-0.35352 1.6553-0.35352 2.5352 0 0.93262 0.10007 1.8214 0.30273 2.666 0.21956 0.82704 0.55767 1.556 1.0137 2.1895 0.456 0.61588 1.0387 1.109 1.748 1.4785 0.70933 0.35193 1.5536 0.5293 2.5332 0.5293 0.79378 0 1.5446-0.16762 2.2539-0.50195 0.72622-0.35193 1.2834-0.88986 1.6719-1.6113h0.05078v1.7949c0.01689 0.96782-0.21071 1.7689-0.68359 2.4023-0.456 0.63348-1.1898 0.95117-2.2031 0.95117-0.64178 0-1.2075-0.14228-1.6973-0.42383-0.48978-0.26395-0.81939-0.74731-0.98828-1.4512h-3.5723c0.05067 0.77425 0.25276 1.435 0.60742 1.9805 0.37156 0.56309 0.8287 1.0192 1.3691 1.3711 0.55733 0.35193 1.1656 0.60726 1.8242 0.76562 0.67556 0.17597 1.3328 0.26562 1.9746 0.26562 1.5031 0 2.7025-0.21245 3.5977-0.63477 0.89511-0.42232 1.5798-0.94076 2.0527-1.5566 0.47289-0.59829 0.777-1.2493 0.91211-1.9531 0.152-0.70386 0.22656-1.3295 0.22656-1.875v-12.775h-3.4199v1.8223h-0.05078c-0.43911-0.79185-0.98782-1.3551-1.6465-1.6895-0.64178-0.33434-1.3926-0.50195-2.2539-0.50195zm16.523 0c-0.99644 0-1.9088 0.18516-2.7363 0.55469-0.81067 0.36953-1.5124 0.88018-2.1035 1.5312-0.59111 0.63348-1.0463 1.3897-1.3672 2.2695s-0.48047 1.831-0.48047 2.8516c0 1.0558 0.15108 2.0225 0.45508 2.9023 0.32089 0.87983 0.76758 1.6361 1.3418 2.2695 0.57422 0.63348 1.276 1.1266 2.1035 1.4785 0.82756 0.33434 1.7569 0.50195 2.7871 0.50195 1.4862 0 2.7517-0.35277 3.7988-1.0566 1.0471-0.70387 1.8254-1.8733 2.332-3.5098h-3.168c-0.11822 0.42232-0.43934 0.82772-0.96289 1.2148-0.52355 0.36953-1.1468 0.55274-1.873 0.55273-1.0133 0-1.7916-0.27286-2.332-0.81836-0.54044-0.5455-0.83605-1.4245-0.88672-2.6387h9.4492c0.06756-1.0558-0.01551-2.0673-0.25195-3.0352-0.23644-0.96782-0.62557-1.8293-1.166-2.5859-0.52356-0.75666-1.1998-1.355-2.0273-1.7949-0.82756-0.45751-1.7974-0.6875-2.9121-0.6875zm16.189 0c-0.76 0-1.5023 0.18516-2.2285 0.55469-0.72622 0.35193-1.3174 0.92299-1.7734 1.7148h-0.07617v-1.9004h-3.4199v13.646h3.5977v-7.1523c0-1.3901 0.21909-2.3841 0.6582-2.9824 0.43911-0.61588 1.1494-0.92383 2.1289-0.92383 0.86133 0 1.4611 0.28066 1.7988 0.84375 0.33777 0.5455 0.50586 1.3816 0.50586 2.5078v7.707h3.5976v-8.3926c0-0.84464-0.0765-1.6106-0.22851-2.2969-0.13511-0.70387-0.37971-1.2925-0.73438-1.7676-0.35466-0.49271-0.84386-0.87277-1.4688-1.1367-0.608-0.28155-1.3948-0.42188-2.3574-0.42188zm-66.063 0.36914 4.3066 6.4668-4.7129 7.1797h4.0293l2.7363-4.3027 2.7344 4.3027h4.1055l-4.8398-7.2578 4.3066-6.3887h-3.9766l-2.2793 3.5645-2.3066-3.5645zm13.275 0 4.584 12.803c0.10133 0.26395 0.15234 0.54461 0.15234 0.84375 0 0.40472-0.11707 0.77504-0.35352 1.1094-0.21956 0.33434-0.56617 0.52729-1.0391 0.58008-0.35467 0.0176-0.70979 0.0098-1.0645-0.02539-0.35467-0.03519-0.70128-0.07028-1.0391-0.10547v3.0879c0.37156 0.03519 0.73518 0.06051 1.0898 0.07813 0.37156 0.03519 0.74368 0.05273 1.1152 0.05273 1.2329 0 2.1943-0.23778 2.8867-0.71289 0.69244-0.47511 1.2326-1.2664 1.6211-2.375l5.4727-15.336h-3.7246l-2.8613 9.3438h-0.05078l-2.9648-9.3438zm-37.48 2.4551c0.59111 0 1.0823 0.12279 1.4707 0.36914 0.38844 0.24635 0.6991 0.57184 0.93555 0.97656 0.25333 0.38713 0.43187 0.84515 0.5332 1.373 0.10133 0.5103 0.15234 1.0482 0.15234 1.6113 0 0.56309-0.05101 1.1069-0.15234 1.6348-0.10133 0.5279-0.27137 1.0035-0.50781 1.4258-0.23644 0.40472-0.5556 0.73021-0.96094 0.97656-0.38844 0.24635-0.87959 0.36914-1.4707 0.36914-0.55733 0-1.038-0.12279-1.4434-0.36914-0.38844-0.26395-0.71806-0.59723-0.98828-1.002-0.25333-0.42232-0.43842-0.89788-0.55664-1.4258s-0.17773-1.0561-0.17773-1.584c-1e-7 -0.56309 0.05101-1.0991 0.15234-1.6094 0.11822-0.5279 0.29481-0.99567 0.53125-1.4004 0.25333-0.40472 0.58295-0.73021 0.98828-0.97656 0.40533-0.24635 0.90303-0.36914 1.4941-0.36914zm15.84 0c0.608 0 1.1142 0.13253 1.5195 0.39648 0.42222 0.24635 0.75184 0.57184 0.98828 0.97656 0.25333 0.40472 0.42992 0.87054 0.53125 1.3984 0.10133 0.5279 0.15234 1.0658 0.15234 1.6113 0 0.5455-0.05101 1.0815-0.15234 1.6094-0.10134 0.5103-0.27792 0.97612-0.53125 1.3984-0.23644 0.40472-0.56606 0.73021-0.98828 0.97656-0.40533 0.24635-0.91153 0.36914-1.5195 0.36914-0.608 0-1.1142-0.12279-1.5195-0.36914s-0.73495-0.57184-0.98828-0.97656c-0.23644-0.42232-0.40648-0.88814-0.50781-1.3984-0.10133-0.5279-0.15234-1.0639-0.15234-1.6094 0-0.5455 0.05101-1.0834 0.15234-1.6113 0.10133-0.5279 0.27137-0.99371 0.50781-1.3984 0.25333-0.40472 0.58295-0.73021 0.98828-0.97656 0.40533-0.26395 0.91153-0.39648 1.5195-0.39648zm42.602 0c0.59111 0 1.0803 0.11499 1.4688 0.34375 0.38844 0.22876 0.70105 0.5367 0.9375 0.92383 0.23644 0.38713 0.40648 0.8354 0.50781 1.3457 0.10133 0.49271 0.15039 1.0209 0.15039 1.584 0 0.4927-0.06606 0.96827-0.20117 1.4258-0.11822 0.43992-0.30526 0.83557-0.55859 1.1875-0.25333 0.35193-0.57445 0.63259-0.96289 0.84375-0.38844 0.21116-0.83513 0.31836-1.3418 0.31836-0.55733 0-1.021-0.12474-1.3926-0.37109-0.37156-0.24635-0.67566-0.56209-0.91211-0.94922-0.21956-0.38713-0.38109-0.81786-0.48242-1.293-0.08444-0.49271-0.12695-0.98581-0.12695-1.4785 0-0.5103 0.05101-0.99366 0.15234-1.4512 0.11822-0.47511 0.29676-0.89025 0.5332-1.2422 0.25333-0.36953 0.55744-0.65993 0.91211-0.87109 0.37156-0.21116 0.80974-0.31641 1.3164-0.31641zm15.535 0c0.87822 0 1.529 0.24753 1.9512 0.74023 0.43911 0.49271 0.74322 1.2138 0.91211 2.1641h-5.8535c0.01689-0.26395 0.0679-0.5641 0.15234-0.89844 0.10133-0.33434 0.26287-0.65008 0.48242-0.94922 0.23644-0.29914 0.54055-0.54667 0.91211-0.74023 0.38845-0.21116 0.86914-0.31641 1.4434-0.31641z" filter="url(#f)" opacity=".3" stroke="#969696" xlink:href="#path141"/>
+ <path d="m0.97202 24.161 43.605-0.0019 0.0508 3.3061-43.6 0.04174z" fill="url(#d)" stroke="#000" stroke-width=".5"/>
+ <path d="m10.283 3.5547v6.8633h-0.05078c-0.40533-0.66867-0.96254-1.1715-1.6719-1.5059-0.69244-0.35193-1.4282-0.52734-2.2051-0.52734-0.96267 0-1.807 0.2027-2.5332 0.60742-0.72622 0.38713-1.3344 0.90556-1.8242 1.5566-0.47289 0.65108-0.83456 1.4092-1.0879 2.2715-0.23644 0.84464-0.35547 1.7236-0.35547 2.6387 0 0.95022 0.11902 1.8643 0.35547 2.7441 0.25333 0.87983 0.615 1.6633 1.0879 2.3496 0.48978 0.66867 1.1065 1.2066 1.8496 1.6113 0.74311 0.38713 1.6044 0.58008 2.584 0.58008 0.86133 0 1.6311-0.15787 2.3066-0.47461 0.69244-0.33434 1.2497-0.87227 1.6719-1.6113h0.05078v1.7422h3.4199v-18.846zm12.875 4.8301c-1.0302 0-1.9596 0.17541-2.7871 0.52734-0.82756 0.33434-1.5358 0.81965-2.127 1.4531-0.59111 0.61588-1.0483 1.3721-1.3691 2.2695-0.32089 0.87983-0.48047 1.866-0.48047 2.957s0.15958 2.0752 0.48047 2.9551c0.32089 0.87983 0.77803 1.6361 1.3691 2.2695 0.59111 0.61588 1.2994 1.0914 2.127 1.4258 0.82756 0.33434 1.7569 0.50195 2.7871 0.50195 1.0302 0 1.9596-0.16762 2.7871-0.50195 0.84444-0.33434 1.5612-0.8099 2.1523-1.4258 0.59111-0.63348 1.0483-1.3897 1.3691-2.2695 0.32089-0.87983 0.48047-1.8641 0.48047-2.9551s-0.15958-2.0772-0.48047-2.957c-0.32089-0.89743-0.77803-1.6536-1.3691-2.2695-0.59111-0.63348-1.3079-1.1188-2.1523-1.4531-0.82756-0.35193-1.7569-0.52734-2.7871-0.52734zm41.715 0c-0.912 0-1.7223 0.18516-2.4316 0.55469-0.69244 0.36953-1.2752 0.87043-1.748 1.5039-0.47289 0.61588-0.83651 1.337-1.0898 2.1641-0.23644 0.80944-0.35352 1.6553-0.35352 2.5352 0 0.93262 0.10007 1.8214 0.30273 2.666 0.21956 0.82704 0.55767 1.556 1.0137 2.1895 0.456 0.61588 1.0387 1.109 1.748 1.4785 0.70933 0.35193 1.5536 0.5293 2.5332 0.5293 0.79378 0 1.5446-0.16762 2.2539-0.50195 0.72622-0.35193 1.2834-0.88986 1.6719-1.6113h0.05078v1.7949c0.01689 0.96782-0.21071 1.7689-0.68359 2.4023-0.456 0.63348-1.1898 0.95117-2.2031 0.95117-0.64178 0-1.2075-0.14228-1.6973-0.42383-0.48978-0.26395-0.81939-0.74731-0.98828-1.4512h-3.5723c0.05067 0.77425 0.25276 1.435 0.60742 1.9805 0.37156 0.56309 0.8287 1.0192 1.3691 1.3711 0.55733 0.35193 1.1656 0.60726 1.8242 0.76562 0.67556 0.17597 1.3328 0.26562 1.9746 0.26562 1.5031 0 2.7025-0.21245 3.5977-0.63477 0.89511-0.42232 1.5798-0.94076 2.0527-1.5566 0.47289-0.59829 0.777-1.2493 0.91211-1.9531 0.152-0.70386 0.22656-1.3295 0.22656-1.875v-12.775h-3.4199v1.8223h-0.05078c-0.43911-0.79185-0.98782-1.3551-1.6465-1.6895-0.64178-0.33434-1.3926-0.50195-2.2539-0.50195zm16.523 0c-0.99644 0-1.9088 0.18516-2.7363 0.55469-0.81067 0.36953-1.5124 0.88017-2.1035 1.5312-0.59111 0.63348-1.0463 1.3897-1.3672 2.2695s-0.48047 1.831-0.48047 2.8516c0 1.0558 0.15108 2.0225 0.45508 2.9023 0.32089 0.87983 0.76758 1.6361 1.3418 2.2695 0.57422 0.63348 1.276 1.1266 2.1035 1.4785 0.82756 0.33434 1.7569 0.50195 2.7871 0.50195 1.4862 0 2.7517-0.35278 3.7988-1.0566 1.0471-0.70386 1.8254-1.8733 2.332-3.5098h-3.168c-0.11822 0.42232-0.43934 0.82772-0.96289 1.2148-0.52355 0.36953-1.1468 0.55274-1.873 0.55273-1.0133 0-1.7916-0.27286-2.332-0.81836-0.54044-0.5455-0.83605-1.4245-0.88672-2.6387h9.4492c0.06756-1.0558-0.01551-2.0673-0.25195-3.0352-0.23644-0.96782-0.62557-1.8293-1.166-2.5859-0.52356-0.75666-1.1998-1.355-2.0273-1.7949-0.82756-0.45751-1.7974-0.6875-2.9121-0.6875zm16.189 0c-0.76 0-1.5023 0.18516-2.2285 0.55469-0.72622 0.35193-1.3174 0.923-1.7734 1.7148h-0.07617v-1.9004h-3.4199v13.646h3.5977v-7.1523c0-1.3901 0.21909-2.3841 0.6582-2.9824 0.43911-0.61588 1.1494-0.92383 2.1289-0.92383 0.86133 0 1.461 0.28066 1.7988 0.84375 0.33778 0.5455 0.50586 1.3816 0.50586 2.5078v7.707h3.5977v-8.3926c0-0.84464-0.0765-1.6106-0.22852-2.2969-0.13511-0.70387-0.3797-1.2925-0.73437-1.7676-0.35466-0.49271-0.84386-0.87277-1.4688-1.1367-0.608-0.28155-1.3948-0.42188-2.3574-0.42188zm-66.062 0.36914 4.3066 6.4668-4.7129 7.1797h4.0293l2.7363-4.3027 2.7344 4.3027h4.1055l-4.8398-7.2578 4.3066-6.3887h-3.9766l-2.2793 3.5645-2.3066-3.5645zm13.275 0 4.584 12.803c0.10133 0.26395 0.15234 0.54461 0.15234 0.84375 0 0.40472-0.11707 0.77504-0.35352 1.1094-0.21956 0.33434-0.56617 0.52729-1.0391 0.58008-0.35467 0.0176-0.70979 0.0098-1.0645-0.02539-0.35467-0.03519-0.70128-0.07027-1.0391-0.10547v3.0879c0.37156 0.03519 0.73518 0.06052 1.0898 0.07813 0.37156 0.03519 0.74368 0.05273 1.1152 0.05273 1.2329 0 2.1943-0.23778 2.8867-0.71289 0.69244-0.47511 1.2326-1.2664 1.6211-2.375l5.4727-15.336h-3.7246l-2.8613 9.3437h-0.05078l-2.9648-9.3437zm-37.48 2.4551c0.59111 0 1.0823 0.12279 1.4707 0.36914s0.6991 0.57184 0.93555 0.97656c0.25333 0.38713 0.43187 0.84515 0.5332 1.373 0.10133 0.5103 0.15234 1.0482 0.15234 1.6113 0 0.56309-0.05101 1.1069-0.15234 1.6348-0.10133 0.5279-0.27137 1.0035-0.50781 1.4258-0.23644 0.40472-0.5556 0.73021-0.96094 0.97656-0.38844 0.24635-0.87959 0.36914-1.4707 0.36914-0.55733 0-1.038-0.12279-1.4434-0.36914-0.38844-0.26395-0.71806-0.59723-0.98828-1.002-0.25333-0.42232-0.43842-0.89788-0.55664-1.4258s-0.17773-1.0561-0.17773-1.584c-1e-7 -0.56309 0.05101-1.0991 0.15234-1.6094 0.11822-0.5279 0.29481-0.99567 0.53125-1.4004 0.25333-0.40472 0.58295-0.73021 0.98828-0.97656 0.40533-0.24635 0.90303-0.36914 1.4941-0.36914zm15.84 0c0.608 0 1.1142 0.13254 1.5195 0.39648 0.42222 0.24635 0.75184 0.57184 0.98828 0.97656 0.25333 0.40472 0.42992 0.87054 0.53125 1.3984 0.10133 0.5279 0.15234 1.0658 0.15234 1.6113 0 0.5455-0.05101 1.0815-0.15234 1.6094-0.10133 0.5103-0.27792 0.97612-0.53125 1.3984-0.23644 0.40472-0.56606 0.73021-0.98828 0.97656-0.40533 0.24635-0.91153 0.36914-1.5195 0.36914-0.608 0-1.1142-0.12279-1.5195-0.36914s-0.73495-0.57184-0.98828-0.97656c-0.23644-0.42232-0.40648-0.88813-0.50781-1.3984-0.10133-0.5279-0.15234-1.0639-0.15234-1.6094 0-0.5455 0.05101-1.0834 0.15234-1.6113 0.10133-0.5279 0.27137-0.99371 0.50781-1.3984 0.25333-0.40472 0.58295-0.73021 0.98828-0.97656 0.40533-0.26395 0.91153-0.39648 1.5195-0.39648zm42.602 0c0.59111 0 1.0803 0.11499 1.4688 0.34375 0.38844 0.22876 0.70106 0.5367 0.9375 0.92383 0.23644 0.38713 0.40648 0.8354 0.50781 1.3457 0.10133 0.49271 0.15039 1.0209 0.15039 1.584 0 0.49271-0.06606 0.96827-0.20117 1.4258-0.11822 0.43992-0.30526 0.83557-0.55859 1.1875-0.25333 0.35193-0.57445 0.63259-0.96289 0.84375-0.38844 0.21116-0.83513 0.31836-1.3418 0.31836-0.55733 0-1.021-0.12474-1.3926-0.37109-0.37156-0.24635-0.67566-0.56209-0.91211-0.94922-0.21956-0.38713-0.38109-0.81786-0.48242-1.293-0.08444-0.49271-0.12695-0.98581-0.12695-1.4785 0-0.5103 0.05101-0.99366 0.15234-1.4512 0.11822-0.47511 0.29676-0.89026 0.5332-1.2422 0.25333-0.36953 0.55744-0.65993 0.91211-0.87109 0.37156-0.21116 0.80974-0.31641 1.3164-0.31641zm15.535 0c0.87822 0 1.529 0.24753 1.9512 0.74024 0.43911 0.49271 0.74322 1.2138 0.91211 2.1641h-5.8535c0.01689-0.26395 0.0679-0.5641 0.15234-0.89844 0.10133-0.33434 0.26287-0.65008 0.48242-0.94922 0.23644-0.29914 0.54055-0.54667 0.91211-0.74023 0.38845-0.21116 0.86914-0.31641 1.4434-0.31641z" fill="url(#e)" stroke="#4665A2" stroke-width=".7"/>
+ <path d="m52.988 27.291c0.99602-1.0359 1.3944-1.8725 1.7928-3.1076l3.8247-0.03984c0.3113 1.6096 0.82413 2.5137 1.6335 3.1474z" fill="url(#b)" stroke="#000" stroke-width=".5"/>
+ <path d="m73.89 24.04 28.885-0.2011-0.12476 3.3879-31.033 0.16229c1.2621-1.0234 1.9665-2.2859 2.2724-3.3491z" fill="url(#c)" stroke="#000" stroke-width=".41788"/>
+ </g>
+</svg>
--- /dev/null
+/*
+ @licstart The following is the entire license notice for the JavaScript code in this file.
+
+ The MIT License (MIT)
+
+ Copyright (C) 1997-2020 by Dimitri van Heesch
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+ and associated documentation files (the "Software"), to deal in the Software without restriction,
+ including without limitation the rights to use, copy, modify, merge, publish, distribute,
+ sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all copies or
+ substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+ @licend The above is the entire license notice for the JavaScript code in this file
+ */
+function toggleVisibility(linkObj)
+{
+ var base = $(linkObj).attr('id');
+ var summary = $('#'+base+'-summary');
+ var content = $('#'+base+'-content');
+ var trigger = $('#'+base+'-trigger');
+ var src=$(trigger).attr('src');
+ if (content.is(':visible')===true) {
+ content.hide();
+ summary.show();
+ $(linkObj).addClass('closed').removeClass('opened');
+ $(trigger).attr('src',src.substring(0,src.length-8)+'closed.png');
+ } else {
+ content.show();
+ summary.hide();
+ $(linkObj).removeClass('closed').addClass('opened');
+ $(trigger).attr('src',src.substring(0,src.length-10)+'open.png');
+ }
+ return false;
+}
+
+function updateStripes()
+{
+ $('table.directory tr').
+ removeClass('even').filter(':visible:even').addClass('even');
+}
+
+function toggleLevel(level)
+{
+ $('table.directory tr').each(function() {
+ var l = this.id.split('_').length-1;
+ var i = $('#img'+this.id.substring(3));
+ var a = $('#arr'+this.id.substring(3));
+ if (l<level+1) {
+ i.removeClass('iconfopen iconfclosed').addClass('iconfopen');
+ a.html('▼');
+ $(this).show();
+ } else if (l==level+1) {
+ i.removeClass('iconfclosed iconfopen').addClass('iconfclosed');
+ a.html('►');
+ $(this).show();
+ } else {
+ $(this).hide();
+ }
+ });
+ updateStripes();
+}
+
+function toggleFolder(id)
+{
+ // the clicked row
+ var currentRow = $('#row_'+id);
+
+ // all rows after the clicked row
+ var rows = currentRow.nextAll("tr");
+
+ var re = new RegExp('^row_'+id+'\\d+_$', "i"); //only one sub
+
+ // only match elements AFTER this one (can't hide elements before)
+ var childRows = rows.filter(function() { return this.id.match(re); });
+
+ // first row is visible we are HIDING
+ if (childRows.filter(':first').is(':visible')===true) {
+ // replace down arrow by right arrow for current row
+ var currentRowSpans = currentRow.find("span");
+ currentRowSpans.filter(".iconfopen").removeClass("iconfopen").addClass("iconfclosed");
+ currentRowSpans.filter(".arrow").html('►');
+ rows.filter("[id^=row_"+id+"]").hide(); // hide all children
+ } else { // we are SHOWING
+ // replace right arrow by down arrow for current row
+ var currentRowSpans = currentRow.find("span");
+ currentRowSpans.filter(".iconfclosed").removeClass("iconfclosed").addClass("iconfopen");
+ currentRowSpans.filter(".arrow").html('▼');
+ // replace down arrows by right arrows for child rows
+ var childRowsSpans = childRows.find("span");
+ childRowsSpans.filter(".iconfopen").removeClass("iconfopen").addClass("iconfclosed");
+ childRowsSpans.filter(".arrow").html('►');
+ childRows.show(); //show all children
+ }
+ updateStripes();
+}
+
+
+function toggleInherit(id)
+{
+ var rows = $('tr.inherit.'+id);
+ var img = $('tr.inherit_header.'+id+' img');
+ var src = $(img).attr('src');
+ if (rows.filter(':first').is(':visible')===true) {
+ rows.css('display','none');
+ $(img).attr('src',src.substring(0,src.length-8)+'closed.png');
+ } else {
+ rows.css('display','table-row'); // using show() causes jump in firefox
+ $(img).attr('src',src.substring(0,src.length-10)+'open.png');
+ }
+}
+/* @license-end */
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all class members with links to the classes they belong to:</div>
+
+<h3><a id="index_a"></a>- a -</h3><ul>
+<li>accumulated()
+: <a class="el" href="classsigc_1_1signal_1_1accumulated.html#a032428476a190d9dea6313f70e5b8a10">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html#a601feadb67ac4aaa7af709af51f654ca">sigc::signal< T_return()>::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html#a31b87e65e2e6be201c18ff7c7c3e87e9">sigc::signal< T_return(T_arg1)>::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html#af6082d36c41f676b54f271f31ca781b6">sigc::signal< T_return(T_arg1, T_arg2)>::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html#ad47d6448e3137d45649656d23b19f89a">sigc::signal< T_return(T_arg1, T_arg2, T_arg3)>::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html#a3197013a55f3afc0fb9451b033c3fe47">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html#a77a966e973f4ab159f0dbb92737dd02e">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html#afe1cea16b0f0296ff874a2793cc51b53">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html#a33552c46e4db86b98bea128fd32d2c08">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#a1cea5890a6ac54f475ae28062c99e4f4">sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil >::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#a94b30a9ffefefc43cb79b4f30ad65237">sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#aa462577f7f52f54b2bf2c87cbb7aa9bc">sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html#a86aae36f669ce2f9d7f1f0ac9a696f6c">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html#a2d21852efcef1d59cc96c8c873e6ce37">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html#a3e41ce87d15bc90960abd857ca80aed9">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html#a0f2cc39e9f222a296072f8c05ad98796">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::accumulated< T_accumulator ></a>
+</li>
+<li>adaptor_functor()
+: <a class="el" href="structsigc_1_1adaptor__functor.html#a39ef4610f8e0f03425b6f4a44b59e5fb">sigc::adaptor_functor< T_functor ></a>
+</li>
+<li>adaptor_type
+: <a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html#ad3bd68364a24b2b6580b523d5301b25c">sigc::adaptor_trait< T_functor, false ></a>
+, <a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html#a449daad4cd77bd1fbfe59d8fae9d9039">sigc::adaptor_trait< T_functor, true ></a>
+, <a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">sigc::adapts< T_functor ></a>
+, <a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ac6004db92703257f83addd412037f1f7">sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ac249b81b5d6fff6e7c4b1d9b47a98077">sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="structsigc_1_1compose1__functor.html#a90d506f177dca8afeaef61b6b5956541">sigc::compose1_functor< T_setter, T_getter ></a>
+, <a class="el" href="structsigc_1_1compose2__functor.html#ac1c9b3dc43cc75ec65fe0708fb4450d8">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a>
+, <a class="el" href="structsigc_1_1exception__catch__functor.html#a5dc4ecab205c7ad5c3954c2572d4cc08">sigc::exception_catch_functor< T_functor, T_catcher, T_return ></a>
+, <a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#aa9803c7bd355ae0674dbfabf346676c0">sigc::exception_catch_functor< T_functor, T_catcher, void ></a>
+, <a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a33b1c4635aad21aac771627a9a9fe60f">sigc::hide_functor< 0, T_functor ></a>
+, <a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a1f2c49ddcd02a3b7f240f0d0e6f0eec5">sigc::hide_functor<-1, T_functor ></a>
+, <a class="el" href="structsigc_1_1retype__functor.html#ace4a0fc864a6417a7cb36adf011177e0">sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 ></a>
+, <a class="el" href="classsigc_1_1track__obj__functor1.html#ab36332c8e8815546730b525f739d9ebf">sigc::track_obj_functor1< T_functor, T_obj1 ></a>
+</li>
+<li>adapts()
+: <a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">sigc::adapts< T_functor ></a>
+</li>
+<li>add_destroy_notify_callback()
+: <a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">sigc::slot_base</a>
+, <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">sigc::trackable</a>
+</li>
+<li>arg1_type_
+: <a class="el" href="classsigc_1_1slot1.html#a4d81838957a9ccc6cb4c104706a37a89">sigc::slot1< T_return, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1slot2.html#ae69b03a4119d61a0a521b0ad5ddaae46">sigc::slot2< T_return, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1slot3.html#ac6791fffc805aa2303713fea377dbaae">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1slot4.html#a4426d0dcf517d0d815d6add3c9490437">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1slot5.html#aeda4706cbac7cb87a276ffeb8bdada16">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1slot6.html#a98240591834da17569f94410684120ba">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1slot7.html#a58edf93a837003d1a69fc77d39fc11a9">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>arg2_type_
+: <a class="el" href="classsigc_1_1slot2.html#af03b1377bbfcdc742a7c00f4c2c419f7">sigc::slot2< T_return, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1slot3.html#a7390ac1945e87a1e0d172fe266a58d72">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1slot4.html#abf1d276525f0120a734b2b054b9cfb3f">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1slot5.html#ad93d2b3cdce1c3990bde0f49693096e1">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1slot6.html#a44b34c5068d0150922cc630400a1962a">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1slot7.html#ad144d8ea3ecb891d358b5b1b969be7e2">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>arg3_type_
+: <a class="el" href="classsigc_1_1slot3.html#a54a09bfe0dd9c518ec22cc14a7e43a23">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1slot4.html#ae1af3fbe3981779b68f5676f46f6085c">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1slot5.html#aab17d4f2a38e02219c1a4757ba268baf">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1slot6.html#a05f153d441986f23d115bf29c92736ca">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1slot7.html#af90cd5954008a84d6459d99de152a08c">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>arg4_type_
+: <a class="el" href="classsigc_1_1slot4.html#aec7f4747dbe5b581c65c07033ca1bfe5">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1slot5.html#afe7fd46dc4b01397db2c2a9c70b02735">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1slot6.html#a285a8d86913eff1b27b89f4d795190c1">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1slot7.html#af42bc9af248b7c2226d93230bd7b1024">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>arg5_type_
+: <a class="el" href="classsigc_1_1slot5.html#ade67aef04bbfd7c6af63e93afc709321">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1slot6.html#a4a304a22b1a1fae56b7998ae4ae3c0e1">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1slot7.html#ad6c1006a29f6fcb721bc39e8d6f82323">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>arg6_type_
+: <a class="el" href="classsigc_1_1slot6.html#ae935d9ad4042e4cfb0730e2855d7882e">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1slot7.html#ae25a8a8663addfce52415a20725a3b3e">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>arg7_type_
+: <a class="el" href="classsigc_1_1slot7.html#a2dc6c96b8d014fab9daea823188ca021">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all class members with links to the classes they belong to:</div>
+
+<h3><a id="index_b"></a>- b -</h3><ul>
+<li>back()
+: <a class="el" href="structsigc_1_1slot__list.html#a09c5090912b6a7920269d3959e9698f4">sigc::slot_list< T_slot ></a>
+</li>
+<li>begin()
+: <a class="el" href="structsigc_1_1slot__list.html#af5d0b9141e3206f2a7512e1ac4cc65fc">sigc::slot_list< T_slot ></a>
+</li>
+<li>bind_functor()
+: <a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ac170bca0fe2af4722cf6e1fd6b3de128">sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ad61bb64a42d144999a94767cd6031259">sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a>
+</li>
+<li>bind_return_functor()
+: <a class="el" href="structsigc_1_1bind__return__functor.html#a1fa9551283794b249cbbdf7d270745d4">sigc::bind_return_functor< T_return, T_functor ></a>
+</li>
+<li>block()
+: <a class="el" href="structsigc_1_1connection.html#a581ae4f2b708cb6be7b081557864d6ec">sigc::connection</a>
+, <a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">sigc::signal_base</a>
+, <a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">sigc::slot_base</a>
+</li>
+<li>blocked()
+: <a class="el" href="structsigc_1_1connection.html#a7c86964aa4b0f339db5842e6c7e604f3">sigc::connection</a>
+, <a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">sigc::signal_base</a>
+, <a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">sigc::slot_base</a>
+</li>
+<li>blocked_
+: <a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">sigc::slot_base</a>
+</li>
+<li>bound1_
+: <a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a5e92e05deb3d9e952a49a338bac42cb4">sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a>
+</li>
+<li>bound_
+: <a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#afbbf5b4d89cf98a1224da5d72554afdc">sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a>
+</li>
+<li>bound_argument()
+: <a class="el" href="classsigc_1_1bound__argument.html#a495bb69a41b38eda5d6ace5a36807a37">sigc::bound_argument< T_type ></a>
+, <a class="el" href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html#afdfab4386d34bd03e82b05a2eb1f2afe">sigc::bound_argument< const_reference_wrapper< T_wrapped > ></a>
+, <a class="el" href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html#a46f705d774a2436055785b7a55830349">sigc::bound_argument< reference_wrapper< T_wrapped > ></a>
+, <a class="el" href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html#a597709183c9a0b753f4674aaab80b4ff">sigc::bound_argument< std::reference_wrapper< T_wrapped > ></a>
+</li>
+<li>bound_const_mem_functor0()
+: <a class="el" href="classsigc_1_1bound__const__mem__functor0.html#a67756fc7a32eb42309a1d55aea2eeb19">sigc::bound_const_mem_functor0< T_return, T_obj ></a>
+</li>
+<li>bound_const_mem_functor1()
+: <a class="el" href="classsigc_1_1bound__const__mem__functor1.html#aca80f40c27a3346521ffee81ba79da77">sigc::bound_const_mem_functor1< T_return, T_obj, T_arg1 ></a>
+</li>
+<li>bound_const_mem_functor2()
+: <a class="el" href="classsigc_1_1bound__const__mem__functor2.html#a6732b8f5b308ff8ff1adea9e3734f4bf">sigc::bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+</li>
+<li>bound_const_mem_functor3()
+: <a class="el" href="classsigc_1_1bound__const__mem__functor3.html#ae63bd158d8ce2571038d4f6382a7bc51">sigc::bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+</li>
+<li>bound_const_mem_functor4()
+: <a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a1d441ea8caf2d2ff8cfca414f259b657">sigc::bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+</li>
+<li>bound_const_mem_functor5()
+: <a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a9e80ad7a6b586eb1d0cc0a4afc9ea1d4">sigc::bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+</li>
+<li>bound_const_mem_functor6()
+: <a class="el" href="classsigc_1_1bound__const__mem__functor6.html#afa0adf0adf9cde73008982d2494f3d7e">sigc::bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+</li>
+<li>bound_const_mem_functor7()
+: <a class="el" href="classsigc_1_1bound__const__mem__functor7.html#a3353dd997ced3fc00f44ee2b8ccb0063">sigc::bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>bound_const_volatile_mem_functor0()
+: <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html#a364e1b19994e41acf1d99d27ffca8924">sigc::bound_const_volatile_mem_functor0< T_return, T_obj ></a>
+</li>
+<li>bound_const_volatile_mem_functor1()
+: <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html#ac99241e0e7ba52e295f6176c03cdd741">sigc::bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+</li>
+<li>bound_const_volatile_mem_functor2()
+: <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a1b629cd2ff30fcaeb035136e190c3f4d">sigc::bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+</li>
+<li>bound_const_volatile_mem_functor3()
+: <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#a7c5661cbb3554624e50c62789f339aaf">sigc::bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+</li>
+<li>bound_const_volatile_mem_functor4()
+: <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#a97b15b931ba6db1852011d252dd3d5f0">sigc::bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+</li>
+<li>bound_const_volatile_mem_functor5()
+: <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#acc05a40bf47bd943c5d822b354a80ae9">sigc::bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+</li>
+<li>bound_const_volatile_mem_functor6()
+: <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#ae07e825b1d3ee4fa7d4dd45eb7f2fbad">sigc::bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+</li>
+<li>bound_const_volatile_mem_functor7()
+: <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#a6f2635a9548c06f2f5090d75df09fbf1">sigc::bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>bound_mem_functor0()
+: <a class="el" href="classsigc_1_1bound__mem__functor0.html#a7de90a27f55055cae43df1425cc78415">sigc::bound_mem_functor0< T_return, T_obj ></a>
+</li>
+<li>bound_mem_functor1()
+: <a class="el" href="classsigc_1_1bound__mem__functor1.html#ad13235c20a9171bd24a4f8ae36577448">sigc::bound_mem_functor1< T_return, T_obj, T_arg1 ></a>
+</li>
+<li>bound_mem_functor2()
+: <a class="el" href="classsigc_1_1bound__mem__functor2.html#a48bc9b34469749461813061d17680ca2">sigc::bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+</li>
+<li>bound_mem_functor3()
+: <a class="el" href="classsigc_1_1bound__mem__functor3.html#aadbbb586e3ba0c44a25c1f3834c4c438">sigc::bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+</li>
+<li>bound_mem_functor4()
+: <a class="el" href="classsigc_1_1bound__mem__functor4.html#a15b592122574775dd2c4804617e1e3dd">sigc::bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+</li>
+<li>bound_mem_functor5()
+: <a class="el" href="classsigc_1_1bound__mem__functor5.html#a179304173879dac0023d49e313125c8c">sigc::bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+</li>
+<li>bound_mem_functor6()
+: <a class="el" href="classsigc_1_1bound__mem__functor6.html#ab2724a290ceef4f2c279156b606e8c88">sigc::bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+</li>
+<li>bound_mem_functor7()
+: <a class="el" href="classsigc_1_1bound__mem__functor7.html#a989011ff72d908959d2f0ad346357706">sigc::bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>bound_volatile_mem_functor0()
+: <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html#a5812d3638dc20b9fe37688d31dde8ed8">sigc::bound_volatile_mem_functor0< T_return, T_obj ></a>
+</li>
+<li>bound_volatile_mem_functor1()
+: <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html#af0b1a108c0080fe202b1d77cae86a7d0">sigc::bound_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+</li>
+<li>bound_volatile_mem_functor2()
+: <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#ac3a72dc9eb316e9f096cb0a93792e368">sigc::bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+</li>
+<li>bound_volatile_mem_functor3()
+: <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#a21c0be5f093ddcd084cc5ad172ceaf92">sigc::bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+</li>
+<li>bound_volatile_mem_functor4()
+: <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#ae2385ee536e72cfbb0d945ba770f2e69">sigc::bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+</li>
+<li>bound_volatile_mem_functor5()
+: <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#af5e4db24b5ba51d92746aa3fee080d49">sigc::bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+</li>
+<li>bound_volatile_mem_functor6()
+: <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#acb8a7befd300496343cf46d8520db04f">sigc::bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+</li>
+<li>bound_volatile_mem_functor7()
+: <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#a18f28191685aa86228328e7016b5c803">sigc::bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all class members with links to the classes they belong to:</div>
+
+<h3><a id="index_c"></a>- c -</h3><ul>
+<li>catcher_
+: <a class="el" href="structsigc_1_1exception__catch__functor.html#af94123d76a61a13258893ed575a019b0">sigc::exception_catch_functor< T_functor, T_catcher, T_return ></a>
+, <a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#acc50467493545db2b55e638f7ac28c42">sigc::exception_catch_functor< T_functor, T_catcher, void ></a>
+</li>
+<li>clear()
+: <a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">sigc::signal_base</a>
+</li>
+<li>compose1_functor()
+: <a class="el" href="structsigc_1_1compose1__functor.html#a1bb831ebfb46a214a6ffda98e77ad044">sigc::compose1_functor< T_setter, T_getter ></a>
+</li>
+<li>compose2_functor()
+: <a class="el" href="structsigc_1_1compose2__functor.html#a72719db97ab3ffdc0176ea3b443ffb60">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a>
+</li>
+<li>connect()
+: <a class="el" href="classsigc_1_1signal0.html#a609b1e0770f47c9081a3de56b65314d2">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#aac2ade0896bd4a982777d5dd6ac75888">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#aa686af4f961b098a23d4f7276437c2b0">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#a3eae0b3796b2736be847f33a5124aacd">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#a5fdb6df3cf74f5c96fb6319eef4d0a39">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#a057789cc27a920700e240f8f3d78dd65">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#a66c302607cf4fb74f5d3352f9c394c9b">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+, <a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base</a>
+</li>
+<li>connected()
+: <a class="el" href="structsigc_1_1connection.html#a307b5df56439539be66f92d6e39f0bce">sigc::connection</a>
+</li>
+<li>connection()
+: <a class="el" href="structsigc_1_1connection.html#a95f80dbbf10fde0b851d78ec12cc2629">sigc::connection</a>
+</li>
+<li>const_iterator
+: <a class="el" href="classsigc_1_1signal0.html#ad4f7c62954f5c270e115d9b2a2df15ea">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#af1e262b35c9574e65b2607cdfcaad707">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#ad507bc5ea29adb2305f8fa91acbd30ee">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#a60e1ef95f82cd8981d61576d1e3f8e94">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#a3d2626edc726047c04c8fe5b9824b958">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#a17e79eed46f178a12d2751eddcf85290">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#ac88a9c4e9bab5ad04c66d3f5d3978f0f">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#a6eef6225eba66a86dd32c3f3b79845f7">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+, <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">sigc::slot_list< T_slot ></a>
+</li>
+<li>const_limit_reference()
+: <a class="el" href="classsigc_1_1const__limit__reference.html#acee8a4c09720730cd5f66696fd018b4c">sigc::const_limit_reference< T_type, I_derives_trackable ></a>
+, <a class="el" href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html#a68f1337800c19036c81512e76e0dd6cd">sigc::const_limit_reference< T_type, true ></a>
+</li>
+<li>const_mem_functor0()
+: <a class="el" href="classsigc_1_1const__mem__functor0.html#a49bba4c8045b8b6933b8f5a854ac98d6">sigc::const_mem_functor0< T_return, T_obj ></a>
+</li>
+<li>const_mem_functor1()
+: <a class="el" href="classsigc_1_1const__mem__functor1.html#aba30421222bd496f9dec9b733fe70447">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a>
+</li>
+<li>const_mem_functor2()
+: <a class="el" href="classsigc_1_1const__mem__functor2.html#a6265bdc51f35d8d5274bfeb8cdafc1dc">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+</li>
+<li>const_mem_functor3()
+: <a class="el" href="classsigc_1_1const__mem__functor3.html#a9921cf28137404e029e3f5d7c291021d">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+</li>
+<li>const_mem_functor4()
+: <a class="el" href="classsigc_1_1const__mem__functor4.html#acdde68d1638c13cd29157d1cb1bd42d2">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+</li>
+<li>const_mem_functor5()
+: <a class="el" href="classsigc_1_1const__mem__functor5.html#a818da40f7c82d6a1fde3009d32bf3920">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+</li>
+<li>const_mem_functor6()
+: <a class="el" href="classsigc_1_1const__mem__functor6.html#a0803b89f79b60c16d87c0372be261211">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+</li>
+<li>const_mem_functor7()
+: <a class="el" href="classsigc_1_1const__mem__functor7.html#add4d7f74905c6bc20afc6f7681f367c0">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>const_reference
+: <a class="el" href="structsigc_1_1slot__list.html#a3ac6e61271e7e8623d1bd493c61f1214">sigc::slot_list< T_slot ></a>
+</li>
+<li>const_reference_wrapper()
+: <a class="el" href="structsigc_1_1const__reference__wrapper.html#a249ae888fb9be126598d81ce339fbf81">sigc::const_reference_wrapper< T_type ></a>
+</li>
+<li>const_reverse_iterator
+: <a class="el" href="classsigc_1_1signal0.html#a476f559a69eef5999c99cd6262a9aa2f">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#aeb327519f808dfec9a723511ef82caa3">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#aacb8fe57ffe01dea5c5fb5af44634287">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#a4ba3eb58c4c5ac2c25f49c48fd0af264">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#a555ce030884fdf2bde788b75db01bedf">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#ad5ba46907fe236e0cff806888696d569">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#aff490e7f75a83aa2f324a859f9071a79">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#ad1ba32ad7dae0c05a4012ada78077505">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+, <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">sigc::slot_list< T_slot ></a>
+</li>
+<li>const_volatile_limit_reference()
+: <a class="el" href="classsigc_1_1const__volatile__limit__reference.html#a9a01809bae79cb1b13ee50ce9d84dcb8">sigc::const_volatile_limit_reference< T_type, I_derives_trackable ></a>
+, <a class="el" href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html#a94bf04779d798bd2737c521d20655122">sigc::const_volatile_limit_reference< T_type, true ></a>
+</li>
+<li>const_volatile_mem_functor0()
+: <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#a8eec4c4ff04b8d5ef7c184e853ea0486">sigc::const_volatile_mem_functor0< T_return, T_obj ></a>
+</li>
+<li>const_volatile_mem_functor1()
+: <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#a25a541c4bef874a6b2d177a3be7ab988">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+</li>
+<li>const_volatile_mem_functor2()
+: <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#ada3da9a8dd692377c90abbfa9bcfe73a">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+</li>
+<li>const_volatile_mem_functor3()
+: <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#af284f300a6b3696f6379dcc9ed97a744">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+</li>
+<li>const_volatile_mem_functor4()
+: <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#aad7b7f5037a0c8d13668f9c350e010ee">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+</li>
+<li>const_volatile_mem_functor5()
+: <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#afe48307086c70740f39f58488a3cbdb5">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+</li>
+<li>const_volatile_mem_functor6()
+: <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#aa921f2d1cea8ddd987cdaa8df6479fab">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+</li>
+<li>const_volatile_mem_functor7()
+: <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#ac71290a7277b022f8a8d7abc4158a7ae">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all class members with links to the classes they belong to:</div>
+
+<h3><a id="index_d"></a>- d -</h3><ul>
+<li>difference_type
+: <a class="el" href="structsigc_1_1slot__const__iterator.html#ac111b0a48ab96f75e720f32171072bc5">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#adb6307ee06c592d67ecef0607f319d5e">sigc::slot_iterator< T_slot ></a>
+</li>
+<li>disconnect()
+: <a class="el" href="structsigc_1_1connection.html#a0452bd182a61650d14a9664d6297ed1b">sigc::connection</a>
+, <a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">sigc::slot_base</a>
+</li>
+<li>do_visit_each()
+: <a class="el" href="structsigc_1_1visitor.html#a9fe5d6be845e622a99a0db5d3621d4b3">sigc::visitor< T_functor ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all class members with links to the classes they belong to:</div>
+
+<h3><a id="index_e"></a>- e -</h3><ul>
+<li>emit()
+: <a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+</li>
+<li>emit_reverse()
+: <a class="el" href="classsigc_1_1signal0.html#abdae39f9a7abd6133c03d65224c227d6">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#a449fc940ae822c4b6ea9282b9b292015">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#ad2d5f3169ba147de8d43fde9e93bac98">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#a97ff4f22c97920a81e3f27aa5d39ba99">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#a0aaf27875cdb8a0ae381372d98871ae1">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#aa6d2e202263e3879f0d3949612d7fcdf">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#a2e8b355902f0646fb34b52b495123167">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#a192581feb2dbcfc9c56692e72e91e9a8">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+</li>
+<li>emitter_type
+: <a class="el" href="classsigc_1_1signal0.html#ac7eafdced2d325d6003327b4360bc2dd">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#a63c6e2b55c8c3af083402bb7f5a66593">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#a01379d580d21de8bc8d0d2d62e6324ea">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#adf54ec96c5fb78d4c8b7fc032a1937ad">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#acf3d1e6d6487c0ecc13ed3eab949eec7">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#a7d77e5fa748b024842bf92e28cf0f4ab">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#acdd2683223e4701f58350152f32f4488">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#a7fa856e67a31c86538db7c289a6870e3">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+</li>
+<li>empty()
+: <a class="el" href="structsigc_1_1connection.html#a810bdde9fbe7ad10bf9d578eebf929de">sigc::connection</a>
+, <a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">sigc::signal_base</a>
+, <a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">sigc::slot_base</a>
+</li>
+<li>end()
+: <a class="el" href="structsigc_1_1slot__list.html#affef6e4e62e4be8743c56aa8753f76d1">sigc::slot_list< T_slot ></a>
+</li>
+<li>erase()
+: <a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">sigc::signal_base</a>
+, <a class="el" href="structsigc_1_1slot__list.html#a092ed557b1519062804a41e9b527e99d">sigc::slot_list< T_slot ></a>
+</li>
+<li>exception_catch_functor()
+: <a class="el" href="structsigc_1_1exception__catch__functor.html#acefeea54e1d83cb64844a956598918fd">sigc::exception_catch_functor< T_functor, T_catcher, T_return ></a>
+, <a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a84b167dc0dd520253776c55eb711c461">sigc::exception_catch_functor< T_functor, T_catcher, void ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all class members with links to the classes they belong to:</div>
+
+<h3><a id="index_f"></a>- f -</h3><ul>
+<li>front()
+: <a class="el" href="structsigc_1_1slot__list.html#ac44ca78cb266a8c46758b276cea151a1">sigc::slot_list< T_slot ></a>
+</li>
+<li>func_destroy_notify
+: <a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">sigc::slot_base</a>
+, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">sigc::trackable</a>
+</li>
+<li>func_ptr_
+: <a class="el" href="classsigc_1_1const__mem__functor0.html#a215359b20450c2afe93496826ac45c1d">sigc::const_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor1.html#af791174008d5b58aa0f4fb42a531cc4a">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor2.html#a4445ff55323e94d525c1b2574ee32ddc">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor3.html#ad86eb326f14c401748d0a118265e558d">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor4.html#ac0feeedacde97bd166141c285fa2c74c">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor5.html#aeb6e66e0304e5c039d97264a3dd7d6e9">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor6.html#a665c77c3da00d474d6d999c394801a98">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor7.html#a255588607e165db8bd25c3bb8d7e1fbe">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#ae0f88c6683fb175845f5f804c2c04ec8">sigc::const_volatile_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#af9da27522999030f09c718dbe164f1f6">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#aac7f64e6cff784ecd6700d0448d8e796">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a6ffedac451ab4f525bd7c9df0b83cf2c">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a0714aabc799c5d41af988650fec71410">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a785d079f14f42cafd052639a1ebdaeb9">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#aed412f2606f91f9c11567c37ae6175bc">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a3f19b8bff74776f040492d3410c54fa1">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1mem__functor0.html#a1f7b51d412900f55e155ecdd848fa283">sigc::mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1mem__functor1.html#af5981be86ea36d59e86234ef5cd2b5a4">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1mem__functor2.html#aa4b00e1d6bb65c1c1791d314b5dcb4d6">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1mem__functor3.html#ac7ed881bf6b6ef8c7ed418ad3bfc0ccc">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1mem__functor4.html#a28282d9285ca1a2075fd8041905a6302">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1mem__functor5.html#a73a58b713dccc6a48b0083063b0df719">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1mem__functor6.html#af07a44f7435cf15228903b0868fac956">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1mem__functor7.html#a779c41d697c3b80d08a06cbcc9a5ea25">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1pointer__functor0.html#af998b64dac7b3c7eeb2e9a2856a4213e">sigc::pointer_functor0< T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor1.html#a864ab55240be5287faf07c341ae9501e">sigc::pointer_functor1< T_arg1, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor2.html#a340680ba8ae5ea67eb0afe33d118c82b">sigc::pointer_functor2< T_arg1, T_arg2, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor3.html#a1ac1e43f2515d64c0da4656cdfac1f44">sigc::pointer_functor3< T_arg1, T_arg2, T_arg3, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor4.html#af7079533ac64ac9ba23eab99e5c54269">sigc::pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor5.html#a1c97e4e7e8598e06802b07cb86b32466">sigc::pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor6.html#a69c965009b6c3b65106c731b20e60368">sigc::pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor7.html#aa092fb6515cb3496529b253b1a57118b">sigc::pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor0.html#a874e91ca403b95bb085ed596257de3ec">sigc::volatile_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor1.html#ad07b2821f95c27c013af4fdce527c1cb">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor2.html#aafe942fe06b2687338ea82b058412d07">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor3.html#acf6a8aebcf4de461e03e9b994a807362">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor4.html#a176ab2202482276e79e6d71ff839c31d">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor5.html#a01d38ddf6e713a47199fba85fd5a8092">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor6.html#aa64e5accf2702a06bffb6ed68fd95022">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor7.html#ac74b72d519805a654529347e4c638e6f">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>function_type
+: <a class="el" href="classsigc_1_1bound__const__mem__functor0.html#a12ae83ad7820bd716ed8a07484a339d9">sigc::bound_const_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor1.html#a65f0cde178bdd7a26fe687a8748dac4e">sigc::bound_const_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor2.html#abe2916ee9b6867554b48370000eb6886">sigc::bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor3.html#ab4e793d8c65bf8754aea133a2473dc6c">sigc::bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a3ffc5790ded15878ce2704072791c4e9">sigc::bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a882a71b51f303ded9d1ce172b522692a">sigc::bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a9cd70f288cac9b8d7ee9695166f3d306">sigc::bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor7.html#ae95db1c3ce4d07122e39dde2c9c5af02">sigc::bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html#a622322ff2ef93f0e611fd6f93f6ccdcc">sigc::bound_const_volatile_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html#ac7a0c09914219d8baf1715675e838e59">sigc::bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a26e4bc5d2c64c1029b760fe7994fee3f">sigc::bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#ae127200c20b69f91ccaf40eb60f2c448">sigc::bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#a2c06c731ae9564be215802a98541d06c">sigc::bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#a54debcbe3edf1a9606aad9cfcc1e004c">sigc::bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#aa8d75053aa097f0632c13bf1185f84a9">sigc::bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#a48030a47276e3eede338fc78c79e5a35">sigc::bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor0.html#a36b5479bfc091c063d44b11ad024393a">sigc::bound_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor1.html#a8e460c2a0eb87dcaf263c984b4dc5888">sigc::bound_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor2.html#a1b0b5d2145f50d19214ff41bd45ab978">sigc::bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor3.html#a66d1aa7ad3edafd8851ee0b334f83efe">sigc::bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor4.html#aeddcfc0ce5fe38259608bfc88af37568">sigc::bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor5.html#a91181f20bd393befce307655486949ad">sigc::bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor6.html#ac92e6b87056623eeec0d09a35f41296d">sigc::bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor7.html#a0fcd4636185a806d055d6b885503863b">sigc::bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html#a9a07aa91b2bd5ef0c4fc1a89bad5d3b0">sigc::bound_volatile_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html#a38ee12aba5c1d6a7c608165a1137219a">sigc::bound_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#a16d5240b9bbb31ae266725d20b0f37d7">sigc::bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#abc967931a7ab1411e02c022035073be5">sigc::bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#a7a30b6a2e3067254fdea50104fea8469">sigc::bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#a1561f499bd4d950fd36ee43ee60db585">sigc::bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#a6eeca5f695bff3c3302e4cf7d222a73d">sigc::bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#afce6246f9f2828a7185b3c696435d70a">sigc::bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor0.html#a5b768319ee81e2aa9e96a900e5e64996">sigc::const_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor1.html#a14e585a05b63c5e4790b3de75cb18c96">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor2.html#a2294d014482fee6845b69ab5bc27daa9">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor3.html#accd266c72527ca411756bd9a4045eac9">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor4.html#a775bb61661f2a7007b36f16ee106a8ad">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor5.html#aa58310b256b11e94d9a757acf60b410a">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor6.html#ad64803b1192e1007887f234b8c7421ac">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor7.html#a73af81d23d0fa816b8ef00acb1970d43">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#a3247f7d0e3804ff455e0996b969f6c59">sigc::const_volatile_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#acc367f8d6ee646c370623650a7ed6cde">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#ac46d1e343e669092d6bb24aa8b5d5dbb">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a472ab7835e2b6792a108f4fcc80d4669">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#ace3cb54e6265ebe06ee2995dd01f2540">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a1d49a5a7086d41d1db2e40aed1273631">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#af8da04ac5f6e2252f963f4f4bb87c9fd">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a7e3bac9b817c848b96e9d1b257be1de5">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1mem__functor0.html#a2b54ee0f1d0b0ca4f25707c85a5d4bab">sigc::mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1mem__functor1.html#a4f10314fc4d7811e126aa0d8dc9fea8c">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1mem__functor2.html#aa584cfe15bb8dc5b2931d2bfd034c118">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1mem__functor3.html#a8da99a5dcfe5ae1cecd6ce93ab91b929">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1mem__functor4.html#a9dcf1ef95187c2588ecf2abb089cc7c8">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1mem__functor5.html#a66e9bb0c9829b13af029ee2127b54eb5">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1mem__functor6.html#a202287b72f6213f64a696b185fb90268">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1mem__functor7.html#a408f0afec5b4c750ca8e1bdab0f8b535">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor0.html#a2f0448d35b580f2b4884292f29b19b2f">sigc::volatile_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor1.html#a49228c222297c3f116b132370c3f054d">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor2.html#a5faa6d84f05d64ff92e9e4ba6b8bcc1f">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor3.html#aadf62624c12ef82ade8114184f0882c9">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor4.html#a697cad0c578cd4ba3e04f6db8a39e283">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor5.html#a43ce719034586bbd097c823376c288ef">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor6.html#a67b3a13a2f595360ff6f78cb96efe9d1">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor7.html#a4ee701fd029c3b7f2f3a3af1aef428a0">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>functor_
+: <a class="el" href="structsigc_1_1adaptor__functor.html#a4faff6b7a82f4f6d92e3d3b0aa8fdca8">sigc::adaptor_functor< T_functor ></a>
+, <a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">sigc::adapts< T_functor ></a>
+</li>
+<li>functor_type
+: <a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html#acb1a7066d665d00e2525c49d089efc0f">sigc::adaptor_trait< T_functor, false ></a>
+, <a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html#ae065e339af2abe58cad43d630328240f">sigc::adaptor_trait< T_functor, true ></a>
+, <a class="el" href="structsigc_1_1functor__trait.html#ac779b3d3d04e78d57b6b2ae4545b1667">sigc::functor_trait< T_functor, I_derives_functor_base, I_can_use_decltype ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Functions</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_a"></a>- a -</h3><ul>
+<li>accumulated()
+: <a class="el" href="classsigc_1_1signal_1_1accumulated.html#a032428476a190d9dea6313f70e5b8a10">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html#a601feadb67ac4aaa7af709af51f654ca">sigc::signal< T_return()>::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html#abbb5481dc26b9efce3b8604eb0f6ea27">sigc::signal< T_return(T_arg1)>::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html#af6082d36c41f676b54f271f31ca781b6">sigc::signal< T_return(T_arg1, T_arg2)>::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html#ad47d6448e3137d45649656d23b19f89a">sigc::signal< T_return(T_arg1, T_arg2, T_arg3)>::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html#a3197013a55f3afc0fb9451b033c3fe47">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html#a3b820b8e12b845648ff1eeff72bf97fa">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html#a3daa5943f5b629a17a547b75743b8829">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html#a33552c46e4db86b98bea128fd32d2c08">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#a54763bd7352a9c84b5e5956b4f65c914">sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil >::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#a94b30a9ffefefc43cb79b4f30ad65237">sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#aa462577f7f52f54b2bf2c87cbb7aa9bc">sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html#ab20d2ddd7330aa974d61ddec753413b6">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html#a994494b04443cda13eef81e13321db83">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html#a0b18943e223f1ae150ee5541673a2e29">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::accumulated< T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html#a239f7a4fefc7cb2cc6c4fb6c9c332d2f">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::accumulated< T_accumulator ></a>
+</li>
+<li>adaptor_functor()
+: <a class="el" href="structsigc_1_1adaptor__functor.html#a39ef4610f8e0f03425b6f4a44b59e5fb">sigc::adaptor_functor< T_functor ></a>
+</li>
+<li>adapts()
+: <a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">sigc::adapts< T_functor ></a>
+</li>
+<li>add_destroy_notify_callback()
+: <a class="el" href="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694">sigc::slot_base</a>
+, <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">sigc::trackable</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Functions</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_b"></a>- b -</h3><ul>
+<li>back()
+: <a class="el" href="structsigc_1_1slot__list.html#a09c5090912b6a7920269d3959e9698f4">sigc::slot_list< T_slot ></a>
+</li>
+<li>begin()
+: <a class="el" href="structsigc_1_1slot__list.html#af5d0b9141e3206f2a7512e1ac4cc65fc">sigc::slot_list< T_slot ></a>
+</li>
+<li>bind_functor()
+: <a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ac170bca0fe2af4722cf6e1fd6b3de128">sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ad61bb64a42d144999a94767cd6031259">sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a>
+</li>
+<li>bind_return_functor()
+: <a class="el" href="structsigc_1_1bind__return__functor.html#a1fa9551283794b249cbbdf7d270745d4">sigc::bind_return_functor< T_return, T_functor ></a>
+</li>
+<li>block()
+: <a class="el" href="structsigc_1_1connection.html#a581ae4f2b708cb6be7b081557864d6ec">sigc::connection</a>
+, <a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">sigc::signal_base</a>
+, <a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9">sigc::slot_base</a>
+</li>
+<li>blocked()
+: <a class="el" href="structsigc_1_1connection.html#a7c86964aa4b0f339db5842e6c7e604f3">sigc::connection</a>
+, <a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">sigc::signal_base</a>
+, <a class="el" href="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517">sigc::slot_base</a>
+</li>
+<li>bound_argument()
+: <a class="el" href="classsigc_1_1bound__argument.html#a495bb69a41b38eda5d6ace5a36807a37">sigc::bound_argument< T_type ></a>
+, <a class="el" href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html#afdfab4386d34bd03e82b05a2eb1f2afe">sigc::bound_argument< const_reference_wrapper< T_wrapped > ></a>
+, <a class="el" href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html#a46f705d774a2436055785b7a55830349">sigc::bound_argument< reference_wrapper< T_wrapped > ></a>
+, <a class="el" href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html#a597709183c9a0b753f4674aaab80b4ff">sigc::bound_argument< std::reference_wrapper< T_wrapped > ></a>
+</li>
+<li>bound_const_mem_functor0()
+: <a class="el" href="classsigc_1_1bound__const__mem__functor0.html#a67756fc7a32eb42309a1d55aea2eeb19">sigc::bound_const_mem_functor0< T_return, T_obj ></a>
+</li>
+<li>bound_const_mem_functor1()
+: <a class="el" href="classsigc_1_1bound__const__mem__functor1.html#aca80f40c27a3346521ffee81ba79da77">sigc::bound_const_mem_functor1< T_return, T_obj, T_arg1 ></a>
+</li>
+<li>bound_const_mem_functor2()
+: <a class="el" href="classsigc_1_1bound__const__mem__functor2.html#a6732b8f5b308ff8ff1adea9e3734f4bf">sigc::bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+</li>
+<li>bound_const_mem_functor3()
+: <a class="el" href="classsigc_1_1bound__const__mem__functor3.html#ae63bd158d8ce2571038d4f6382a7bc51">sigc::bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+</li>
+<li>bound_const_mem_functor4()
+: <a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a1d441ea8caf2d2ff8cfca414f259b657">sigc::bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+</li>
+<li>bound_const_mem_functor5()
+: <a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a9e80ad7a6b586eb1d0cc0a4afc9ea1d4">sigc::bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+</li>
+<li>bound_const_mem_functor6()
+: <a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a4c6a29813f84239bfc224e36d3ada58c">sigc::bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+</li>
+<li>bound_const_mem_functor7()
+: <a class="el" href="classsigc_1_1bound__const__mem__functor7.html#a3353dd997ced3fc00f44ee2b8ccb0063">sigc::bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>bound_const_volatile_mem_functor0()
+: <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html#a364e1b19994e41acf1d99d27ffca8924">sigc::bound_const_volatile_mem_functor0< T_return, T_obj ></a>
+</li>
+<li>bound_const_volatile_mem_functor1()
+: <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html#ac99241e0e7ba52e295f6176c03cdd741">sigc::bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+</li>
+<li>bound_const_volatile_mem_functor2()
+: <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a1b629cd2ff30fcaeb035136e190c3f4d">sigc::bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+</li>
+<li>bound_const_volatile_mem_functor3()
+: <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#a3fbbc6533b408ccde3d517b1f2a38223">sigc::bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+</li>
+<li>bound_const_volatile_mem_functor4()
+: <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#a97b15b931ba6db1852011d252dd3d5f0">sigc::bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+</li>
+<li>bound_const_volatile_mem_functor5()
+: <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#acc05a40bf47bd943c5d822b354a80ae9">sigc::bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+</li>
+<li>bound_const_volatile_mem_functor6()
+: <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#ae07e825b1d3ee4fa7d4dd45eb7f2fbad">sigc::bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+</li>
+<li>bound_const_volatile_mem_functor7()
+: <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#a6f2635a9548c06f2f5090d75df09fbf1">sigc::bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>bound_mem_functor0()
+: <a class="el" href="classsigc_1_1bound__mem__functor0.html#a7de90a27f55055cae43df1425cc78415">sigc::bound_mem_functor0< T_return, T_obj ></a>
+</li>
+<li>bound_mem_functor1()
+: <a class="el" href="classsigc_1_1bound__mem__functor1.html#ad13235c20a9171bd24a4f8ae36577448">sigc::bound_mem_functor1< T_return, T_obj, T_arg1 ></a>
+</li>
+<li>bound_mem_functor2()
+: <a class="el" href="classsigc_1_1bound__mem__functor2.html#a48bc9b34469749461813061d17680ca2">sigc::bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+</li>
+<li>bound_mem_functor3()
+: <a class="el" href="classsigc_1_1bound__mem__functor3.html#aadbbb586e3ba0c44a25c1f3834c4c438">sigc::bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+</li>
+<li>bound_mem_functor4()
+: <a class="el" href="classsigc_1_1bound__mem__functor4.html#a15b592122574775dd2c4804617e1e3dd">sigc::bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+</li>
+<li>bound_mem_functor5()
+: <a class="el" href="classsigc_1_1bound__mem__functor5.html#a179304173879dac0023d49e313125c8c">sigc::bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+</li>
+<li>bound_mem_functor6()
+: <a class="el" href="classsigc_1_1bound__mem__functor6.html#ab2724a290ceef4f2c279156b606e8c88">sigc::bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+</li>
+<li>bound_mem_functor7()
+: <a class="el" href="classsigc_1_1bound__mem__functor7.html#a989011ff72d908959d2f0ad346357706">sigc::bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>bound_volatile_mem_functor0()
+: <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html#a5812d3638dc20b9fe37688d31dde8ed8">sigc::bound_volatile_mem_functor0< T_return, T_obj ></a>
+</li>
+<li>bound_volatile_mem_functor1()
+: <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html#af0b1a108c0080fe202b1d77cae86a7d0">sigc::bound_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+</li>
+<li>bound_volatile_mem_functor2()
+: <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#ac3a72dc9eb316e9f096cb0a93792e368">sigc::bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+</li>
+<li>bound_volatile_mem_functor3()
+: <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#a21c0be5f093ddcd084cc5ad172ceaf92">sigc::bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+</li>
+<li>bound_volatile_mem_functor4()
+: <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#ae2385ee536e72cfbb0d945ba770f2e69">sigc::bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+</li>
+<li>bound_volatile_mem_functor5()
+: <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#af5e4db24b5ba51d92746aa3fee080d49">sigc::bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+</li>
+<li>bound_volatile_mem_functor6()
+: <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#acb8a7befd300496343cf46d8520db04f">sigc::bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+</li>
+<li>bound_volatile_mem_functor7()
+: <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#a18f28191685aa86228328e7016b5c803">sigc::bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Functions</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_c"></a>- c -</h3><ul>
+<li>clear()
+: <a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">sigc::signal_base</a>
+</li>
+<li>compose1_functor()
+: <a class="el" href="structsigc_1_1compose1__functor.html#a1bb831ebfb46a214a6ffda98e77ad044">sigc::compose1_functor< T_setter, T_getter ></a>
+</li>
+<li>compose2_functor()
+: <a class="el" href="structsigc_1_1compose2__functor.html#a72719db97ab3ffdc0176ea3b443ffb60">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a>
+</li>
+<li>connect()
+: <a class="el" href="classsigc_1_1signal0.html#a609b1e0770f47c9081a3de56b65314d2">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#aac2ade0896bd4a982777d5dd6ac75888">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#aa686af4f961b098a23d4f7276437c2b0">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#a3eae0b3796b2736be847f33a5124aacd">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#a5fdb6df3cf74f5c96fb6319eef4d0a39">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#a057789cc27a920700e240f8f3d78dd65">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#a1754aa5a8959da0bb55e42864a8365af">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+, <a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">sigc::signal_base</a>
+</li>
+<li>connected()
+: <a class="el" href="structsigc_1_1connection.html#a307b5df56439539be66f92d6e39f0bce">sigc::connection</a>
+</li>
+<li>connection()
+: <a class="el" href="structsigc_1_1connection.html#a95f80dbbf10fde0b851d78ec12cc2629">sigc::connection</a>
+</li>
+<li>const_limit_reference()
+: <a class="el" href="classsigc_1_1const__limit__reference.html#acee8a4c09720730cd5f66696fd018b4c">sigc::const_limit_reference< T_type, I_derives_trackable ></a>
+, <a class="el" href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html#a68f1337800c19036c81512e76e0dd6cd">sigc::const_limit_reference< T_type, true ></a>
+</li>
+<li>const_mem_functor0()
+: <a class="el" href="classsigc_1_1const__mem__functor0.html#a49bba4c8045b8b6933b8f5a854ac98d6">sigc::const_mem_functor0< T_return, T_obj ></a>
+</li>
+<li>const_mem_functor1()
+: <a class="el" href="classsigc_1_1const__mem__functor1.html#aba30421222bd496f9dec9b733fe70447">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a>
+</li>
+<li>const_mem_functor2()
+: <a class="el" href="classsigc_1_1const__mem__functor2.html#a6265bdc51f35d8d5274bfeb8cdafc1dc">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+</li>
+<li>const_mem_functor3()
+: <a class="el" href="classsigc_1_1const__mem__functor3.html#a9921cf28137404e029e3f5d7c291021d">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+</li>
+<li>const_mem_functor4()
+: <a class="el" href="classsigc_1_1const__mem__functor4.html#acdde68d1638c13cd29157d1cb1bd42d2">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+</li>
+<li>const_mem_functor5()
+: <a class="el" href="classsigc_1_1const__mem__functor5.html#a818da40f7c82d6a1fde3009d32bf3920">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+</li>
+<li>const_mem_functor6()
+: <a class="el" href="classsigc_1_1const__mem__functor6.html#a7a5e8a3a981a615a545aab358efa9472">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+</li>
+<li>const_mem_functor7()
+: <a class="el" href="classsigc_1_1const__mem__functor7.html#add4d7f74905c6bc20afc6f7681f367c0">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>const_reference_wrapper()
+: <a class="el" href="structsigc_1_1const__reference__wrapper.html#a249ae888fb9be126598d81ce339fbf81">sigc::const_reference_wrapper< T_type ></a>
+</li>
+<li>const_volatile_limit_reference()
+: <a class="el" href="classsigc_1_1const__volatile__limit__reference.html#a9a01809bae79cb1b13ee50ce9d84dcb8">sigc::const_volatile_limit_reference< T_type, I_derives_trackable ></a>
+, <a class="el" href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html#a94bf04779d798bd2737c521d20655122">sigc::const_volatile_limit_reference< T_type, true ></a>
+</li>
+<li>const_volatile_mem_functor0()
+: <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#a8eec4c4ff04b8d5ef7c184e853ea0486">sigc::const_volatile_mem_functor0< T_return, T_obj ></a>
+</li>
+<li>const_volatile_mem_functor1()
+: <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#a25a541c4bef874a6b2d177a3be7ab988">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+</li>
+<li>const_volatile_mem_functor2()
+: <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#ad99060cf675fb65cbc00f2b8e9ec3068">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+</li>
+<li>const_volatile_mem_functor3()
+: <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#af284f300a6b3696f6379dcc9ed97a744">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+</li>
+<li>const_volatile_mem_functor4()
+: <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#aad7b7f5037a0c8d13668f9c350e010ee">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+</li>
+<li>const_volatile_mem_functor5()
+: <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#afe48307086c70740f39f58488a3cbdb5">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+</li>
+<li>const_volatile_mem_functor6()
+: <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#aa921f2d1cea8ddd987cdaa8df6479fab">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+</li>
+<li>const_volatile_mem_functor7()
+: <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#ac71290a7277b022f8a8d7abc4158a7ae">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Functions</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_d"></a>- d -</h3><ul>
+<li>disconnect()
+: <a class="el" href="structsigc_1_1connection.html#a0452bd182a61650d14a9664d6297ed1b">sigc::connection</a>
+, <a class="el" href="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857">sigc::slot_base</a>
+</li>
+<li>do_visit_each()
+: <a class="el" href="structsigc_1_1visitor.html#a9fe5d6be845e622a99a0db5d3621d4b3">sigc::visitor< T_functor ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Functions</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_e"></a>- e -</h3><ul>
+<li>emit()
+: <a class="el" href="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+</li>
+<li>emit_reverse()
+: <a class="el" href="classsigc_1_1signal0.html#abdae39f9a7abd6133c03d65224c227d6">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#a449fc940ae822c4b6ea9282b9b292015">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#ad2d5f3169ba147de8d43fde9e93bac98">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#a97ff4f22c97920a81e3f27aa5d39ba99">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#a0aaf27875cdb8a0ae381372d98871ae1">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#aa6d2e202263e3879f0d3949612d7fcdf">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#a2e8b355902f0646fb34b52b495123167">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#a192581feb2dbcfc9c56692e72e91e9a8">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+</li>
+<li>empty()
+: <a class="el" href="structsigc_1_1connection.html#a810bdde9fbe7ad10bf9d578eebf929de">sigc::connection</a>
+, <a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">sigc::signal_base</a>
+, <a class="el" href="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef">sigc::slot_base</a>
+</li>
+<li>end()
+: <a class="el" href="structsigc_1_1slot__list.html#affef6e4e62e4be8743c56aa8753f76d1">sigc::slot_list< T_slot ></a>
+</li>
+<li>erase()
+: <a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">sigc::signal_base</a>
+, <a class="el" href="structsigc_1_1slot__list.html#a092ed557b1519062804a41e9b527e99d">sigc::slot_list< T_slot ></a>
+</li>
+<li>exception_catch_functor()
+: <a class="el" href="structsigc_1_1exception__catch__functor.html#acefeea54e1d83cb64844a956598918fd">sigc::exception_catch_functor< T_functor, T_catcher, T_return ></a>
+, <a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a84b167dc0dd520253776c55eb711c461">sigc::exception_catch_functor< T_functor, T_catcher, void ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Functions</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_f"></a>- f -</h3><ul>
+<li>front()
+: <a class="el" href="structsigc_1_1slot__list.html#abcd398b9cb6fe9506e548d121081163a">sigc::slot_list< T_slot ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Functions</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_h"></a>- h -</h3><ul>
+<li>hide_functor()
+: <a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a7d5504f337ab7a4b6f709219c9e98222">sigc::hide_functor< 0, T_functor ></a>
+, <a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a4c8d774e447991a6a920b9f3fca63205">sigc::hide_functor<-1, T_functor ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Functions</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_i"></a>- i -</h3><ul>
+<li>impl()
+: <a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">sigc::signal_base</a>
+</li>
+<li>insert()
+: <a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">sigc::signal_base</a>
+, <a class="el" href="structsigc_1_1slot__list.html#a34c421956609463692527793e49b87ae">sigc::slot_list< T_slot ></a>
+</li>
+<li>invoke()
+: <a class="el" href="classsigc_1_1bound__argument.html#af1cf20526bade89328a1ed398055bbba">sigc::bound_argument< T_type ></a>
+, <a class="el" href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html#aa08b2efa73ad0a928f0be217da940671">sigc::bound_argument< const_reference_wrapper< T_wrapped > ></a>
+, <a class="el" href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html#adbeb73917559e0764bf367dfc6c4141d">sigc::bound_argument< reference_wrapper< T_wrapped > ></a>
+, <a class="el" href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html#a38950827998907494c25397f01552730">sigc::bound_argument< std::reference_wrapper< T_wrapped > ></a>
+, <a class="el" href="classsigc_1_1const__limit__reference.html#abb05a4234000dbf4a256b446d3ef580d">sigc::const_limit_reference< T_type, I_derives_trackable ></a>
+, <a class="el" href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html#a694136bfdbcc64717181ea2cc4714fa3">sigc::const_limit_reference< T_type, true ></a>
+, <a class="el" href="classsigc_1_1const__volatile__limit__reference.html#ac09d022e8991a946d49a714df8b2f1c7">sigc::const_volatile_limit_reference< T_type, I_derives_trackable ></a>
+, <a class="el" href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html#a0a44e756c7478717ef8b34fb5b0c7004">sigc::const_volatile_limit_reference< T_type, true ></a>
+, <a class="el" href="classsigc_1_1limit__reference.html#affd2902cd78ccdae45c499058c83e992">sigc::limit_reference< T_type, I_derives_trackable ></a>
+, <a class="el" href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html#a6c8067da8b8c15361127ad25efab6903">sigc::limit_reference< T_type, true ></a>
+, <a class="el" href="classsigc_1_1volatile__limit__reference.html#a0157cc89d9db4032c7a8f9159ebaeff3">sigc::volatile_limit_reference< T_type, I_derives_trackable ></a>
+, <a class="el" href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html#aebad0975106ae62368e4f5c0ee0a6170">sigc::volatile_limit_reference< T_type, true ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Functions</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_l"></a>- l -</h3><ul>
+<li>limit_reference()
+: <a class="el" href="classsigc_1_1limit__reference.html#a58bf17e1eaa63d86336c831fa885bc66">sigc::limit_reference< T_type, I_derives_trackable ></a>
+, <a class="el" href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html#a26ef98ef1f11a4b5891d426e9722c2c8">sigc::limit_reference< T_type, true ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Functions</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_m"></a>- m -</h3><ul>
+<li>make_slot()
+: <a class="el" href="classsigc_1_1signal0.html#a3295536428e5e0d6478ac10e2daff736">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#a87513117263fd39d5a5a86e0fb8b2a78">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#a844d15c61c83933575e7953b29365efa">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#a332be8eb0ee22c11a2e1d140ca1bc2df">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#aebcf1389e689b8d43ff739df118482bc">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#a7b01481c87d4ec9c03095e76cb502c24">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#a97ae4180e80ac60b564fec58d1732317">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#a3f468c8b6cc55d675c75d0184bd8e38a">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+</li>
+<li>mem_functor0()
+: <a class="el" href="classsigc_1_1mem__functor0.html#ad598cd301fc54f3aa4da2b9e3c16bc81">sigc::mem_functor0< T_return, T_obj ></a>
+</li>
+<li>mem_functor1()
+: <a class="el" href="classsigc_1_1mem__functor1.html#ab97c2206275025d8d1e7665c12322eba">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a>
+</li>
+<li>mem_functor2()
+: <a class="el" href="classsigc_1_1mem__functor2.html#a691e21d47b7a54b67605812f7e089299">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+</li>
+<li>mem_functor3()
+: <a class="el" href="classsigc_1_1mem__functor3.html#abc94be96c346537bca09c73a342f5ccd">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+</li>
+<li>mem_functor4()
+: <a class="el" href="classsigc_1_1mem__functor4.html#a9774f0ab47d023f5bccdb9960c4fcdee">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+</li>
+<li>mem_functor5()
+: <a class="el" href="classsigc_1_1mem__functor5.html#a9048a4a2216e20f9f34380020f5b67ec">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+</li>
+<li>mem_functor6()
+: <a class="el" href="classsigc_1_1mem__functor6.html#aaa43195f4b4e39c76c10478539d35172">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+</li>
+<li>mem_functor7()
+: <a class="el" href="classsigc_1_1mem__functor7.html#afbb9b8ecaa25e0dd85c0f3d539f198b4">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Functions</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_n"></a>- n -</h3><ul>
+<li>notify()
+: <a class="el" href="structsigc_1_1connection.html#ad45fe90d68fe295e76e130b070e97070">sigc::connection</a>
+</li>
+<li>notify_callbacks()
+: <a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">sigc::trackable</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Functions</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_o"></a>- o -</h3><ul>
+<li>operator bool()
+: <a class="el" href="structsigc_1_1connection.html#a93215e1ea86c5fd0a465b2c4dba1257e">sigc::connection</a>
+, <a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">sigc::slot_base</a>
+</li>
+<li>operator const T_type &()
+: <a class="el" href="structsigc_1_1const__reference__wrapper.html#a2cf7a981855668dfb69e98cfaa6eb779">sigc::const_reference_wrapper< T_type ></a>
+</li>
+<li>operator T_type &()
+: <a class="el" href="structsigc_1_1reference__wrapper.html#ae0b2f512b6a2555b489ed9dd229efc1c">sigc::reference_wrapper< T_type ></a>
+</li>
+<li>operator!=()
+: <a class="el" href="structsigc_1_1slot__const__iterator.html#a0139736ee01df37af11f3551d76a2b53">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#a880c8929759eca2fc7fb55cb0c813c55">sigc::slot_iterator< T_slot ></a>
+</li>
+<li>operator()()
+: <a class="el" href="structsigc_1_1adaptor__functor.html#aa8f3859324cce86596f0eb81b7bb6037">sigc::adaptor_functor< T_functor ></a>
+, <a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a40d96a28bc0a1b7d11e267cc1d7bc517">sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a636774490286342a00251061eb5c550d">sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="structsigc_1_1bind__return__functor.html#a35959a6f4d5f6ddc83f603ee67d25981">sigc::bind_return_functor< T_return, T_functor ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor0.html#a7949abb2e0a675ab7faccf4b0c2b5480">sigc::bound_const_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor1.html#a4ba51a05a053caf20d9306efb0f05791">sigc::bound_const_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor2.html#a00df32df2a5bafc0adb39da243ad3a3d">sigc::bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor3.html#aabad5390e5b2671de1b9fbba7bf1cda6">sigc::bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a4db87f79d355f2ca4f5ff20d47c35ee3">sigc::bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a89a861b0925989a0e845399443eee20a">sigc::bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a6bc7018118bbf55444f4d9250cf3ce65">sigc::bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor7.html#a941b925ad1f628cde49bb268be8daf4a">sigc::bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html#abbe8bbaa0d3d7318046be146fe6fda03">sigc::bound_const_volatile_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html#a0c520be9f25daa56ca9aba061edb7e77">sigc::bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a434acb850963a28b1a5a4662fad2b5d5">sigc::bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#af14d93c72657777d2257e3db60f20a01">sigc::bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#ac1593becd15c2704535c9b50482503f9">sigc::bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#a7f70def3a438e6735b67f669c8fc107a">sigc::bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#a9cd3a5dd70008fe70d17712cfee0f470">sigc::bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#a8fe1055d39082226d8acb3201b7b5ce7">sigc::bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor0.html#a8f0ea7caa1c5858b44ebdb0bcf4ba74a">sigc::bound_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor1.html#af9d43a802f122d38d264b3f662bcfe43">sigc::bound_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor2.html#a09d48d61cc092e3f12c8ac4df4449596">sigc::bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor3.html#aa61ed1a1c920069032ffd5427d24a771">sigc::bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor4.html#a0a9d2fb52ef15ae8d4e56238217c0539">sigc::bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor5.html#aa1de6366cd9e5f0ea037287438a8072f">sigc::bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor6.html#ad44376814c73959398026d4e0df3d401">sigc::bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor7.html#ab0c379b445a5655f55f8260c699e7053">sigc::bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html#a5726bcc0d34cff2356976bc586d36b44">sigc::bound_volatile_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html#a989556175b19d8e13c34727f231228ad">sigc::bound_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#a5a93614f492dacd37dd1cfd94cc033b3">sigc::bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#af5b4934a8e75fd7c32d41a989ec67f66">sigc::bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#a22702ad82b54c77d93fb6d0481896d8f">sigc::bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#aaf0765f195ee2efef0536dfb854af9e4">sigc::bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#aa8aa3006bba7344c630f6f8adb3507d5">sigc::bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#ad1ab1d5cf45600c5369a0a119a5a89ad">sigc::bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="structsigc_1_1compose1__functor.html#ae7c074e7656595157b0f421028e34609">sigc::compose1_functor< T_setter, T_getter ></a>
+, <a class="el" href="structsigc_1_1compose2__functor.html#af39ab33c42d6e7c715b9f5e8ba4eb556">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor0.html#ac388853f99f074e549c8784d1a38f46b">sigc::const_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor1.html#a3a575262ae2d62c39c52280017956a95">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor2.html#aafbf14880952214525553f4b419bf5c6">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor3.html#aa123c4fb39116ca1a28896cfd029b1de">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor4.html#a5b178876ca9fbec1fa2339819939a9e7">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor5.html#aaceffe6505aed22dd5af369231914965">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor6.html#a023fd4cb845234b50c5dee1f4147cde9">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor7.html#ab49dc9f302ef22e4b76043d9bc2f5062">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#adfd64d64707c012329915edf19190772">sigc::const_volatile_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#a9af06968e1db65f5bd136175e10d250f">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#a9d024cf10df876df77183e1fb79a52ec">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a47374a80a3a61b69e39478ca9a4a4776">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a589c68eddffeb3399838d2af7f5b6d19">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a7b1fde7647e7e936b29c97797835ca7b">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#adff33012b1d7a20cb39c41c19b1db9a5">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a9cb200c4d7a95edf269ede2b9c7ab060">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="structsigc_1_1exception__catch__functor.html#a5bb82bbe1b0491cd5c53680eb5cd6b03">sigc::exception_catch_functor< T_functor, T_catcher, T_return ></a>
+, <a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#ade12d3049fdb07307d0852aa9a90f1b6">sigc::exception_catch_functor< T_functor, T_catcher, void ></a>
+, <a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a599128c72562bd8de98c37f046471080">sigc::hide_functor< 0, T_functor ></a>
+, <a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#af4b6fe456f259ae4a9973c2feaebb9f5">sigc::hide_functor<-1, T_functor ></a>
+, <a class="el" href="classsigc_1_1mem__functor0.html#a0a8b70a8f59ddbdc3f1a9892c634bf48">sigc::mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1mem__functor1.html#a11fa461ba0bbddc9e5a7dd687e90591b">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1mem__functor2.html#ad5d0f74803537d1ed8b9678ac2da57d5">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1mem__functor3.html#ae7496f451661d60b287d528a7cfcaf82">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1mem__functor4.html#aef140dac7b4876793fac8a006aad0a62">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1mem__functor5.html#a7ad7a4d81470125047755dfa8509c6dc">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1mem__functor6.html#afc40dbe8ea11726018dfa7c1ca435f3d">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1mem__functor7.html#ad8e9031dc12742265d834a5529b1f00d">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1pointer__functor0.html#a56db821303c19ec3345679d80d6ef96e">sigc::pointer_functor0< T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor1.html#a3c978e35c107326078f3e33afcdd1235">sigc::pointer_functor1< T_arg1, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor2.html#af3d1d778be1730e170c42c52511d6926">sigc::pointer_functor2< T_arg1, T_arg2, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor3.html#adf560c1e583b2216bba4de3027e3a05e">sigc::pointer_functor3< T_arg1, T_arg2, T_arg3, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor4.html#a42875d789a30fb04395dbef76d720989">sigc::pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor5.html#aa2f399d3f76e802670c8a08ede82c40c">sigc::pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor6.html#ac35109048b7360e1436e2b4e3a53d1cf">sigc::pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor7.html#a564941861ee4b84b9b61a1f247f0cfa1">sigc::pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return ></a>
+, <a class="el" href="structsigc_1_1retype__functor.html#abfd54e4b77096f76bb0e880b6b7b81e1">sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 ></a>
+, <a class="el" href="structsigc_1_1retype__return__functor.html#a7e3b161bfa746f69a2af64a00af7cbd2">sigc::retype_return_functor< T_return, T_functor ></a>
+, <a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#af181f5a8134c5a834e2ad0ed7590fbfe">sigc::retype_return_functor< void, T_functor ></a>
+, <a class="el" href="classsigc_1_1signal0.html#a2dd3042c0681542ed6f2de5840f713a1">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#a828907c11f5c18d9522e5d5139484620">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#ac8b73c0624273b8dae819255961ea6a3">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#aa7ae5338d6a883a28c61ff202e43547f">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#a8523a4d47c3a6469fcc50da9977afdb8">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#a7a5bb7b92f49e99354caf50bfef16907">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#affec011fd6e9605f10e50fdd4db424d8">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#ac6fd43215c8f19082402387359330071">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1slot0.html#afa926436a4b0734f0adc2a485ccfe36a">sigc::slot0< T_return ></a>
+, <a class="el" href="classsigc_1_1slot1.html#ae9082daf31fdbb57da71e8c38a9ae1ab">sigc::slot1< T_return, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1slot2.html#aa2abda2a910db19bbb7a2a08d867e358">sigc::slot2< T_return, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1slot3.html#addbe340b1f547308035707236e690e66">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1slot4.html#a02b0d861a47418b9dbf73ab7db67b0a9">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1slot5.html#a3f2d9fa2c9747d6c7fc329213446c71d">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1slot6.html#ac2d6449f2928138c434c474050c7c192">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#a4038d1a1c7a34bbb344b61a8f43c23f6">sigc::slot< T_return(T_arg...)></a>
+, <a class="el" href="classsigc_1_1track__obj__functor1.html#a3da19bfd10f0b9f84ae83b06f8211ae6">sigc::track_obj_functor1< T_functor, T_obj1 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor0.html#aa5df40ec8fb385594c673a07f3ff8044">sigc::volatile_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor1.html#a98cdb61b4c623e44d5b60650098bddfd">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor2.html#a814c8abe52fa858da9f8dfbda8efafc9">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor3.html#a39944451f3bb1538828e45b66f082ea0">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor4.html#a86a0e482790971e3674b9ba488e10127">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor5.html#ab6449c487e42fc9810c0f8d5a6cc243f">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor6.html#a2fdda8079c742fd0366c3fc057ea45e5">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor7.html#a05ed4811582f583a1a1e11b1a8951a21">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>operator*()
+: <a class="el" href="structsigc_1_1slot__const__iterator.html#a37c9a5d5bba252e41a628bd1c87fd883">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#aa01dddd6f7b4e1a726a55cd1d430f398">sigc::slot_iterator< T_slot ></a>
+</li>
+<li>operator++()
+: <a class="el" href="structsigc_1_1slot__const__iterator.html#aed166d716b032a781d2169c919cefdc9">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#af5a3b852c1c6e8f69c41f64a17204758">sigc::slot_iterator< T_slot ></a>
+</li>
+<li>operator--()
+: <a class="el" href="structsigc_1_1slot__const__iterator.html#a1c1d7d7798914c80d6a60d87c4b24c0a">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#a8aeef4e41dc0930beaa8d6a37b27775c">sigc::slot_iterator< T_slot ></a>
+</li>
+<li>operator->()
+: <a class="el" href="structsigc_1_1slot__const__iterator.html#afd0ff56e0779787da2c7dfdb0ef4630c">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#a0a77bd2eccf05cecbdf3b690c5301540">sigc::slot_iterator< T_slot ></a>
+</li>
+<li>operator=()
+: <a class="el" href="structsigc_1_1connection.html#a016094b53bafdc9ce593febb68cb00a5">sigc::connection</a>
+, <a class="el" href="classsigc_1_1signal0.html#a4e8311eac2fd7f8ecd10bff8225ed9e3">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#a29cd06bf91f96f11c5f29237b8afbb71">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#abeb05d9a2b40882bad753fccad6522be">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#a0c398a25051e920bc4338f35b4bf7df6">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#a05908db9c09a9c513529cd8b2106f913">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#a2c3d9a6d8b499da389672f44f8044ce6">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#ad7a4ab249b17bffccbfe441aa1420dd9">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#af8a93a4c8fb0b78fa6578e7dc95f5751">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal.html#adeccc0c1c698e33c1da15c7f667f2a23">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4.html#acbc101f4d7b4e460929593bac336957f">sigc::signal< T_return()></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html#a1014db39eed6f085ab79116510005e4c">sigc::signal< T_return(T_arg1)></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html#abdcf63e52e05fd88654a7e688abd57b1">sigc::signal< T_return(T_arg1, T_arg2)></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html#a43ee800d35a162d99893f6a55f5a7c72">sigc::signal< T_return(T_arg1, T_arg2, T_arg3)></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html#a838a70902714d4cb065ea1bf22e0f376">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html#a95b7d55776c477cae58859f01a043d6e">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html#a249b8264efb4167bf468a6b4c01fe6b5">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html#aaa92f0fe77bca0af86a3a0ddd77bc96b">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a08ac3766c65bb61177b49a62667a5a53">sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a418026bd364a6b5510f0227f497b9473">sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ab610351f5cdf9f332d9a1003a0481ab3">sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a8a0166f439840b854ab3253fa831bb03">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a7e84970efac0339e7ebaaa46540ef0cc">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a4d6e1453a0b4284cc19996e36cff5eef">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a6cbe2b81b53c97bc39c26bbedcb070f1">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a>
+, <a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">sigc::signal_base</a>
+, <a class="el" href="classsigc_1_1slot0.html#a95205051379e5d5657bac78c9b3b8d49">sigc::slot0< T_return ></a>
+, <a class="el" href="classsigc_1_1slot1.html#a2e0d65cfc434718b6c5f7d7135ac384e">sigc::slot1< T_return, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1slot2.html#aeda5a84c674376aa0800a0bf876bb5fa">sigc::slot2< T_return, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1slot3.html#ac40a1cefaf9c356a691dfea6819094b8">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1slot4.html#ac2fb7f8ae312ced5b7436f0a0d062132">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1slot5.html#a24d22be7be827080b34109c625bad7fd">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1slot6.html#a078ab12d6b08bd132041b4787f99ea85">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1slot7.html#af6bf09a0b3c09245257af113e70269d2">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1slot.html#ac7beb1ab973b6cd124d2cdea3f0c1e0c">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#a22759a1af0d37b9e7432bbb046ceff8a">sigc::slot< T_return(T_arg...)></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a62c6b78bd545f7b6a2b0b85a6c3e6b00">sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a88a00e43c5ed084441655b2f9e32c621">sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a98c52bf9ca78dc5f940ec5f5ca466bd9">sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a190287bba2fd66fd0448c586660d1e41">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#aebe6238dace66568d5135f1a7d41e8d1">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a3ca127357feda698616f9ed7209653ff">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a5146567efe93808fbba32c114d2f302e">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a>
+, <a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">sigc::slot_base</a>
+, <a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable</a>
+</li>
+<li>operator==()
+: <a class="el" href="structsigc_1_1slot__const__iterator.html#af88c3fcadb7ce415fcad4bd5dafad087">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#af2b4e16f15258f6cd98f8049afd0b88d">sigc::slot_iterator< T_slot ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Functions</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_p"></a>- p -</h3><ul>
+<li>pointer_functor0()
+: <a class="el" href="classsigc_1_1pointer__functor0.html#a9ae3efd5c13c738db815f619499004d7">sigc::pointer_functor0< T_return ></a>
+</li>
+<li>pointer_functor1()
+: <a class="el" href="classsigc_1_1pointer__functor1.html#a6ce467c0641f8e3e0d91f3b843b07c3f">sigc::pointer_functor1< T_arg1, T_return ></a>
+</li>
+<li>pointer_functor2()
+: <a class="el" href="classsigc_1_1pointer__functor2.html#a2977aa1d72f5f0fd6c778b60ad791b9c">sigc::pointer_functor2< T_arg1, T_arg2, T_return ></a>
+</li>
+<li>pointer_functor3()
+: <a class="el" href="classsigc_1_1pointer__functor3.html#a1a4909d1444e4456a89eb5852933d1cc">sigc::pointer_functor3< T_arg1, T_arg2, T_arg3, T_return ></a>
+</li>
+<li>pointer_functor4()
+: <a class="el" href="classsigc_1_1pointer__functor4.html#ab8e3bf143e71c5ffe8f155ace0f895a8">sigc::pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return ></a>
+</li>
+<li>pointer_functor5()
+: <a class="el" href="classsigc_1_1pointer__functor5.html#abf1e06db145e4554ec53964ca79171cf">sigc::pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return ></a>
+</li>
+<li>pointer_functor6()
+: <a class="el" href="classsigc_1_1pointer__functor6.html#a26551fa703a65a9a14190c7579a3b77d">sigc::pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return ></a>
+</li>
+<li>pointer_functor7()
+: <a class="el" href="classsigc_1_1pointer__functor7.html#a1268abfa3437c0977517dd4cd0548080">sigc::pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return ></a>
+</li>
+<li>pop_back()
+: <a class="el" href="structsigc_1_1slot__list.html#abb28f82ef0cbc78a86a4becd61b0c9ff">sigc::slot_list< T_slot ></a>
+</li>
+<li>pop_front()
+: <a class="el" href="structsigc_1_1slot__list.html#a9244005ecc265b07b7f451e63662686e">sigc::slot_list< T_slot ></a>
+</li>
+<li>push_back()
+: <a class="el" href="structsigc_1_1slot__list.html#a5c7401657a6020c14616e62b20949de8">sigc::slot_list< T_slot ></a>
+</li>
+<li>push_front()
+: <a class="el" href="structsigc_1_1slot__list.html#a5bb241c13cb363825f787ecd244ebf7d">sigc::slot_list< T_slot ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Functions</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_r"></a>- r -</h3><ul>
+<li>rbegin()
+: <a class="el" href="structsigc_1_1slot__list.html#a898411734692d01a320b20a20d9e6978">sigc::slot_list< T_slot ></a>
+</li>
+<li>reference_wrapper()
+: <a class="el" href="structsigc_1_1reference__wrapper.html#a05dfcad06f2af395c5e2daa9600d455a">sigc::reference_wrapper< T_type ></a>
+</li>
+<li>remove_destroy_notify_callback()
+: <a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">sigc::slot_base</a>
+, <a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">sigc::trackable</a>
+</li>
+<li>rend()
+: <a class="el" href="structsigc_1_1slot__list.html#ae4759ca19577b31dca5116292e7de19c">sigc::slot_list< T_slot ></a>
+</li>
+<li>retype_functor()
+: <a class="el" href="structsigc_1_1retype__functor.html#a30f35ce3d25b7fd571fbd3ef730de225">sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 ></a>
+</li>
+<li>retype_return_functor()
+: <a class="el" href="structsigc_1_1retype__return__functor.html#aa9546db86a6d1cfa7224a3a0cbad4827">sigc::retype_return_functor< T_return, T_functor ></a>
+, <a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#a720e802de29a72d1e15626b1719844bc">sigc::retype_return_functor< void, T_functor ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Functions</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_s"></a>- s -</h3><ul>
+<li>set_parent()
+: <a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">sigc::slot_base</a>
+</li>
+<li>signal()
+: <a class="el" href="classsigc_1_1signal.html#a50432d1aebfbee5ef17a3f434d0c50bf">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4.html#aefdfdd54adc65612b58929298274453c">sigc::signal< T_return()></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html#acc30f0949e699fbff85d341162298761">sigc::signal< T_return(T_arg1)></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html#a13d95a6b3058ddbd0f55fd00953cdee5">sigc::signal< T_return(T_arg1, T_arg2)></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html#ac22b59e41db40b6cbe6ac4b71d048170">sigc::signal< T_return(T_arg1, T_arg2, T_arg3)></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html#a8d26e7db0ca474d71736c778e0264f4c">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html#a016fcefe1eb805926dafad10f970f826">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html#a6ec07b9037eeeab8094beb440d80407b">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html#a9b9928bf9b40cae47599be1f4f7f85dc">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a59107d243fe3408d64e4e963d5023dcb">sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a7561df6caf1f508eff71f035db8260c1">sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a3ad9be2894fd3f78bfde9488207ff502">sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a3866d625025ecae063d59e81f86ec836">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a51f9443b48b006a65114bdd18d13cd4b">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a5e64ba037f3567ab5dbb49811a447b2c">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a09609c04d7601601c9726aef1c74ecc7">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a>
+</li>
+<li>signal0()
+: <a class="el" href="classsigc_1_1signal0.html#a2fb24e11a8f645e5122646ea2b4a5d2f">sigc::signal0< T_return, T_accumulator ></a>
+</li>
+<li>signal1()
+: <a class="el" href="classsigc_1_1signal1.html#aba62d8d0b9591bcfd728f8ae8a22d600">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+</li>
+<li>signal2()
+: <a class="el" href="classsigc_1_1signal2.html#a47aba9b19bc2bef0be7183022567e3ea">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+</li>
+<li>signal3()
+: <a class="el" href="classsigc_1_1signal3.html#a52731959f272612fd6abfe8850c5c8cf">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+</li>
+<li>signal4()
+: <a class="el" href="classsigc_1_1signal4.html#a2d469f516a9edac2b20d7f6cf46e821a">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+</li>
+<li>signal5()
+: <a class="el" href="classsigc_1_1signal5.html#af717d1a6fd8612da84dce33fe6640b7a">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+</li>
+<li>signal6()
+: <a class="el" href="classsigc_1_1signal6.html#a0244dde296bd892c590c86ced5281e3b">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+</li>
+<li>signal7()
+: <a class="el" href="classsigc_1_1signal7.html#ab6d54db53a164fb459fcb342d4b45ff0">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+</li>
+<li>signal_base()
+: <a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">sigc::signal_base</a>
+</li>
+<li>size()
+: <a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">sigc::signal_base</a>
+</li>
+<li>slot()
+: <a class="el" href="classsigc_1_1slot.html#ac53122c7f0f1f4dd9493e9ac88837ae2">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#ae7d852d9ac2c9a6a37564a0f4aed3872">sigc::slot< T_return(T_arg...)></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#abdb48282bb8b1b5404fcea6474eca5a5">sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ad34e10be904557368c241f53e972c8e7">sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a32b5350736a34c13c5e64d3ef6f5ba84">sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a0e8a890566381060e52ffbd74cc4cca4">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#afb4ec5a164ca622ab9c1a97e61e9cfdc">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a81c9e625279217aee1ae00696927c39e">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a290753f903665f059c25a4f71c9a9e16">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a>
+</li>
+<li>slot0()
+: <a class="el" href="classsigc_1_1slot0.html#a8681082ecd439d5b294922e4d27a3f49">sigc::slot0< T_return ></a>
+</li>
+<li>slot1()
+: <a class="el" href="classsigc_1_1slot1.html#aa8ac5eadba778c11a424e255889e67f6">sigc::slot1< T_return, T_arg1 ></a>
+</li>
+<li>slot2()
+: <a class="el" href="classsigc_1_1slot2.html#a3f9f6cf199bbb40011eca25eb9da67c2">sigc::slot2< T_return, T_arg1, T_arg2 ></a>
+</li>
+<li>slot3()
+: <a class="el" href="classsigc_1_1slot3.html#ac477d74beed45b2b3e26d19b083147ad">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a>
+</li>
+<li>slot4()
+: <a class="el" href="classsigc_1_1slot4.html#acf9e9b169fddb40079618f870172f535">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+</li>
+<li>slot5()
+: <a class="el" href="classsigc_1_1slot5.html#abcf315edb57a1a23ab7f4a0d25e57736">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+</li>
+<li>slot6()
+: <a class="el" href="classsigc_1_1slot6.html#a3c763adcaa8b9c34c808ef0f15b1fc48">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+</li>
+<li>slot7()
+: <a class="el" href="classsigc_1_1slot7.html#aa9b64dc6516b8a0d55f46e4737eaaf8b">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>slot_base()
+: <a class="el" href="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a">sigc::slot_base</a>
+</li>
+<li>slot_const_iterator()
+: <a class="el" href="structsigc_1_1slot__const__iterator.html#a2b9e80b87a3400bb6f794c07f90d2d47">sigc::slot_const_iterator< T_slot ></a>
+</li>
+<li>slot_iterator()
+: <a class="el" href="structsigc_1_1slot__iterator.html#a82d4023ad9dc38dcde4cae6bf65cd8c8">sigc::slot_iterator< T_slot ></a>
+</li>
+<li>slot_list()
+: <a class="el" href="structsigc_1_1slot__list.html#aa83ff2d263581f80f9d15d14fa31bc7a">sigc::slot_list< T_slot ></a>
+</li>
+<li>slots()
+: <a class="el" href="classsigc_1_1signal0.html#a5576113ddfd6b92a96f86072262307f9">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#a7653b68e6a3b8445de91f89060bf2600">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#ac28b0205aa1e60cc5ce062d4d8545323">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#ab9606b708078956a758b81503f956bee">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#ae490f1a6802c40a4c3b12e1580520c88">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#ad6a4ae2a214d8710be6e36bb425587fc">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#af44115a7bfa4586fc5312259a1df9567">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#a68153d9079b4881352113079cd6216f7">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Functions</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_t"></a>- t -</h3><ul>
+<li>test()
+: <a class="el" href="structsigc_1_1deduce__result__type.html#a46816d343f0924170208d220b7e599f4">sigc::deduce_result_type< T_functor, T_args ></a>
+</li>
+<li>track_obj_functor1()
+: <a class="el" href="classsigc_1_1track__obj__functor1.html#a1bcc00d3b665af8f40fa18936fab5304">sigc::track_obj_functor1< T_functor, T_obj1 ></a>
+</li>
+<li>track_obj_functor2()
+: <a class="el" href="classsigc_1_1track__obj__functor2.html#ae12b4c85e92a265c011fccf090fa6947">sigc::track_obj_functor2< T_functor, T_obj1, T_obj2 ></a>
+</li>
+<li>track_obj_functor3()
+: <a class="el" href="classsigc_1_1track__obj__functor3.html#add83622dc2ad7cd561d2c59768eea45a">sigc::track_obj_functor3< T_functor, T_obj1, T_obj2, T_obj3 ></a>
+</li>
+<li>track_obj_functor4()
+: <a class="el" href="classsigc_1_1track__obj__functor4.html#a29f48beae82cf67da9b70a51da35a2e9">sigc::track_obj_functor4< T_functor, T_obj1, T_obj2, T_obj3, T_obj4 ></a>
+</li>
+<li>track_obj_functor5()
+: <a class="el" href="classsigc_1_1track__obj__functor5.html#a1f0481289e8c48acc4cc6561c8f0c8b6">sigc::track_obj_functor5< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5 ></a>
+</li>
+<li>track_obj_functor6()
+: <a class="el" href="classsigc_1_1track__obj__functor6.html#a70b36db3f8cafb77c48269c3e4c68714">sigc::track_obj_functor6< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6 ></a>
+</li>
+<li>track_obj_functor7()
+: <a class="el" href="classsigc_1_1track__obj__functor7.html#a77667be610a480c7afdb928533b02651">sigc::track_obj_functor7< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6, T_obj7 ></a>
+</li>
+<li>trackable()
+: <a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">sigc::trackable</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Functions</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_u"></a>- u -</h3><ul>
+<li>unblock()
+: <a class="el" href="structsigc_1_1connection.html#a15abcbfa76f1e5d8601cf4ad4176ed50">sigc::connection</a>
+, <a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">sigc::signal_base</a>
+, <a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">sigc::slot_base</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Functions</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_v"></a>- v -</h3><ul>
+<li>visit()
+: <a class="el" href="classsigc_1_1bound__argument.html#ab29e53c5e983c45e4963e0ecace26465">sigc::bound_argument< T_type ></a>
+, <a class="el" href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html#a11b6cda42100c2c463e50942c41ff9eb">sigc::bound_argument< const_reference_wrapper< T_wrapped > ></a>
+, <a class="el" href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html#a5123890110dc1013071e68a615692ce3">sigc::bound_argument< reference_wrapper< T_wrapped > ></a>
+, <a class="el" href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html#a3d34b13540ac33e677024727ffd3a36e">sigc::bound_argument< std::reference_wrapper< T_wrapped > ></a>
+, <a class="el" href="classsigc_1_1const__limit__reference.html#aa7486303566b2a9a74e55561083ed3d9">sigc::const_limit_reference< T_type, I_derives_trackable ></a>
+, <a class="el" href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html#abe87b8e67b8a26658a5d6f45b036721a">sigc::const_limit_reference< T_type, true ></a>
+, <a class="el" href="classsigc_1_1const__volatile__limit__reference.html#a41c17ef86e8c65998ba42097c7ad5f09">sigc::const_volatile_limit_reference< T_type, I_derives_trackable ></a>
+, <a class="el" href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html#a332d07b8ef0005163f02df234f014814">sigc::const_volatile_limit_reference< T_type, true ></a>
+, <a class="el" href="classsigc_1_1limit__reference.html#affeb3929fdc606c8fb7f8f29fa6fd12d">sigc::limit_reference< T_type, I_derives_trackable ></a>
+, <a class="el" href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html#a85e56a8140929d71b2bdbd091e348c3a">sigc::limit_reference< T_type, true ></a>
+, <a class="el" href="classsigc_1_1volatile__limit__reference.html#a4d67fe2d9d27c326136a9e5ac13a1a75">sigc::volatile_limit_reference< T_type, I_derives_trackable ></a>
+, <a class="el" href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html#a187454d57b2c1edefb5594fcd0175835">sigc::volatile_limit_reference< T_type, true ></a>
+</li>
+<li>volatile_limit_reference()
+: <a class="el" href="classsigc_1_1volatile__limit__reference.html#acb3e6e1ecc628343f94faae718b58066">sigc::volatile_limit_reference< T_type, I_derives_trackable ></a>
+, <a class="el" href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html#aa0b69d0a82616d6db2eb86d7a041df23">sigc::volatile_limit_reference< T_type, true ></a>
+</li>
+<li>volatile_mem_functor0()
+: <a class="el" href="classsigc_1_1volatile__mem__functor0.html#aa4e5e279480d50940eb4b73b9c61b938">sigc::volatile_mem_functor0< T_return, T_obj ></a>
+</li>
+<li>volatile_mem_functor1()
+: <a class="el" href="classsigc_1_1volatile__mem__functor1.html#a30ec3be683a2c466b23da53c8025608b">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+</li>
+<li>volatile_mem_functor2()
+: <a class="el" href="classsigc_1_1volatile__mem__functor2.html#a273bbe27bc7b190d8457408cd328c1f9">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+</li>
+<li>volatile_mem_functor3()
+: <a class="el" href="classsigc_1_1volatile__mem__functor3.html#ad2319eebf06194ff516c27f581cbd7a5">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+</li>
+<li>volatile_mem_functor4()
+: <a class="el" href="classsigc_1_1volatile__mem__functor4.html#a5ba462855081b617085e59e7566927a7">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+</li>
+<li>volatile_mem_functor5()
+: <a class="el" href="classsigc_1_1volatile__mem__functor5.html#abe1011a71cd8e78d248e072fb7d60231">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+</li>
+<li>volatile_mem_functor6()
+: <a class="el" href="classsigc_1_1volatile__mem__functor6.html#a782bbd4bff8bd939a008ceb9e0511bae">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+</li>
+<li>volatile_mem_functor7()
+: <a class="el" href="classsigc_1_1volatile__mem__functor7.html#a07834a50703bf92aad9bc167fa256d24">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Functions</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index__7E"></a>- ~ -</h3><ul>
+<li>~connection()
+: <a class="el" href="structsigc_1_1connection.html#a99678ccb2be5c20719f37e469416578a">sigc::connection</a>
+</li>
+<li>~exception_catch_functor()
+: <a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a1537e7d0175046d65522bd960149bb62">sigc::exception_catch_functor< T_functor, T_catcher, void ></a>
+</li>
+<li>~signal_base()
+: <a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">sigc::signal_base</a>
+</li>
+<li>~slot_base()
+: <a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">sigc::slot_base</a>
+</li>
+<li>~trackable()
+: <a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">sigc::trackable</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all class members with links to the classes they belong to:</div>
+
+<h3><a id="index_g"></a>- g -</h3><ul>
+<li>get1_
+: <a class="el" href="structsigc_1_1compose2__functor.html#af5404ffb509175690aa896932571e8bf">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a>
+</li>
+<li>get2_
+: <a class="el" href="structsigc_1_1compose2__functor.html#af8404295ebbcb968a798c9fdf3f3d527">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a>
+</li>
+<li>get_
+: <a class="el" href="structsigc_1_1compose1__functor.html#abc9151caeb78b1cd79ce1eb6984dc066">sigc::compose1_functor< T_setter, T_getter ></a>
+</li>
+<li>getter1_type
+: <a class="el" href="structsigc_1_1compose2__functor.html#ab7ab82eee45e8df9116a5a2b7c12c39c">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a>
+</li>
+<li>getter2_type
+: <a class="el" href="structsigc_1_1compose2__functor.html#a75e252684d06f75f036043df56d8df69">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a>
+</li>
+<li>getter_type
+: <a class="el" href="structsigc_1_1compose1__functor.html#ad54c2d62658fb7a47da41df0ccfc618c">sigc::compose1_functor< T_setter, T_getter ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all class members with links to the classes they belong to:</div>
+
+<h3><a id="index_h"></a>- h -</h3><ul>
+<li>hide_functor()
+: <a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a7d5504f337ab7a4b6f709219c9e98222">sigc::hide_functor< 0, T_functor ></a>
+, <a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a4c8d774e447991a6a920b9f3fca63205">sigc::hide_functor<-1, T_functor ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all class members with links to the classes they belong to:</div>
+
+<h3><a id="index_i"></a>- i -</h3><ul>
+<li>i_
+: <a class="el" href="structsigc_1_1slot__const__iterator.html#a5e8020f4f1c3da18fcac4c9babee306f">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#a5e113a9e58ce7e16a11838a203b72649">sigc::slot_iterator< T_slot ></a>
+</li>
+<li>impl()
+: <a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">sigc::signal_base</a>
+</li>
+<li>impl_
+: <a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">sigc::signal_base</a>
+</li>
+<li>insert()
+: <a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">sigc::signal_base</a>
+, <a class="el" href="structsigc_1_1slot__list.html#a34c421956609463692527793e49b87ae">sigc::slot_list< T_slot ></a>
+</li>
+<li>invoke()
+: <a class="el" href="classsigc_1_1bound__argument.html#af1cf20526bade89328a1ed398055bbba">sigc::bound_argument< T_type ></a>
+, <a class="el" href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html#aa08b2efa73ad0a928f0be217da940671">sigc::bound_argument< const_reference_wrapper< T_wrapped > ></a>
+, <a class="el" href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html#adbeb73917559e0764bf367dfc6c4141d">sigc::bound_argument< reference_wrapper< T_wrapped > ></a>
+, <a class="el" href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html#a38950827998907494c25397f01552730">sigc::bound_argument< std::reference_wrapper< T_wrapped > ></a>
+, <a class="el" href="classsigc_1_1const__limit__reference.html#abb05a4234000dbf4a256b446d3ef580d">sigc::const_limit_reference< T_type, I_derives_trackable ></a>
+, <a class="el" href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html#a694136bfdbcc64717181ea2cc4714fa3">sigc::const_limit_reference< T_type, true ></a>
+, <a class="el" href="classsigc_1_1const__volatile__limit__reference.html#ac09d022e8991a946d49a714df8b2f1c7">sigc::const_volatile_limit_reference< T_type, I_derives_trackable ></a>
+, <a class="el" href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html#a0a44e756c7478717ef8b34fb5b0c7004">sigc::const_volatile_limit_reference< T_type, true ></a>
+, <a class="el" href="classsigc_1_1limit__reference.html#affd2902cd78ccdae45c499058c83e992">sigc::limit_reference< T_type, I_derives_trackable ></a>
+, <a class="el" href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html#a6c8067da8b8c15361127ad25efab6903">sigc::limit_reference< T_type, true ></a>
+, <a class="el" href="classsigc_1_1volatile__limit__reference.html#a0157cc89d9db4032c7a8f9159ebaeff3">sigc::volatile_limit_reference< T_type, I_derives_trackable ></a>
+, <a class="el" href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html#aebad0975106ae62368e4f5c0ee0a6170">sigc::volatile_limit_reference< T_type, true ></a>
+</li>
+<li>iterator
+: <a class="el" href="classsigc_1_1signal0.html#ad61e875748cf4e1c2a6d89a930ae093e">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#ab61e2d1fcaf903dffbb26b01800907fb">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#a658ba1c6468882c9b1d480be2bbaf55e">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#a8029a48126a2018947a2b6680ddabe6b">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#a31e8354263a3097bba9c63b8494143f0">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#acee689b441305fcee098345729fc28f3">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#a1acee11287974cdac1bc63c856e5331d">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+, <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">sigc::slot_list< T_slot ></a>
+</li>
+<li>iterator_category
+: <a class="el" href="structsigc_1_1slot__const__iterator.html#afc9dff16373a2fa7a4f373bd48a852c6">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#a0c882521b418b9faaac879a1d337ace5">sigc::slot_iterator< T_slot ></a>
+</li>
+<li>iterator_type
+: <a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">sigc::signal_base</a>
+, <a class="el" href="structsigc_1_1slot__const__iterator.html#a3466a35177b6a0999a12ff0ee10e91b9">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#a189fa620b9d90dc1a224d9ad91da5011">sigc::slot_iterator< T_slot ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all class members with links to the classes they belong to:</div>
+
+<h3><a id="index_l"></a>- l -</h3><ul>
+<li>limit_reference()
+: <a class="el" href="classsigc_1_1limit__reference.html#a58bf17e1eaa63d86336c831fa885bc66">sigc::limit_reference< T_type, I_derives_trackable ></a>
+, <a class="el" href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html#a26ef98ef1f11a4b5891d426e9722c2c8">sigc::limit_reference< T_type, true ></a>
+</li>
+<li>list_
+: <a class="el" href="structsigc_1_1slot__list.html#a2c5b3ecf068ec93cdc34a4ae8d48313c">sigc::slot_list< T_slot ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all class members with links to the classes they belong to:</div>
+
+<h3><a id="index_m"></a>- m -</h3><ul>
+<li>make_slot()
+: <a class="el" href="classsigc_1_1signal0.html#a3295536428e5e0d6478ac10e2daff736">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#a87513117263fd39d5a5a86e0fb8b2a78">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#a844d15c61c83933575e7953b29365efa">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#a332be8eb0ee22c11a2e1d140ca1bc2df">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#aebcf1389e689b8d43ff739df118482bc">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#a7b01481c87d4ec9c03095e76cb502c24">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#a97ae4180e80ac60b564fec58d1732317">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#a3f468c8b6cc55d675c75d0184bd8e38a">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+</li>
+<li>mem_functor0()
+: <a class="el" href="classsigc_1_1mem__functor0.html#ad598cd301fc54f3aa4da2b9e3c16bc81">sigc::mem_functor0< T_return, T_obj ></a>
+</li>
+<li>mem_functor1()
+: <a class="el" href="classsigc_1_1mem__functor1.html#ab97c2206275025d8d1e7665c12322eba">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a>
+</li>
+<li>mem_functor2()
+: <a class="el" href="classsigc_1_1mem__functor2.html#a691e21d47b7a54b67605812f7e089299">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+</li>
+<li>mem_functor3()
+: <a class="el" href="classsigc_1_1mem__functor3.html#abc94be96c346537bca09c73a342f5ccd">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+</li>
+<li>mem_functor4()
+: <a class="el" href="classsigc_1_1mem__functor4.html#a9774f0ab47d023f5bccdb9960c4fcdee">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+</li>
+<li>mem_functor5()
+: <a class="el" href="classsigc_1_1mem__functor5.html#a9048a4a2216e20f9f34380020f5b67ec">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+</li>
+<li>mem_functor6()
+: <a class="el" href="classsigc_1_1mem__functor6.html#aaa43195f4b4e39c76c10478539d35172">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+</li>
+<li>mem_functor7()
+: <a class="el" href="classsigc_1_1mem__functor7.html#afbb9b8ecaa25e0dd85c0f3d539f198b4">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all class members with links to the classes they belong to:</div>
+
+<h3><a id="index_n"></a>- n -</h3><ul>
+<li>notify()
+: <a class="el" href="structsigc_1_1connection.html#ad45fe90d68fe295e76e130b070e97070">sigc::connection</a>
+</li>
+<li>notify_callbacks()
+: <a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">sigc::trackable</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all class members with links to the classes they belong to:</div>
+
+<h3><a id="index_o"></a>- o -</h3><ul>
+<li>obj_
+: <a class="el" href="classsigc_1_1bound__const__mem__functor0.html#afe36947825350dc17d7fed286f57c32a">sigc::bound_const_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor1.html#ac4141561bf43206a396d082dd0089fb2">sigc::bound_const_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor2.html#a3994b65f2ec0b45f5b502f07bf7baca1">sigc::bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor3.html#ac4b0ceb88bda73c90d84b1320e274621">sigc::bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a78490633e22357be6e0a0fcf124121b5">sigc::bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a71f8b7b3a9971d58209c3008d5e32d79">sigc::bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a152f10d5c46eb9d7d582a6e4cb747baf">sigc::bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor7.html#a2b59ccc18d96b4b2ec0f6828a5c2a6e0">sigc::bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html#adfea0aeaf66e1531da58af3051327949">sigc::bound_const_volatile_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html#a4c6537ee7b64251b8f418047cb9fd87d">sigc::bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a28eef54f97c2468f3385358b75d6cb70">sigc::bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#a65b0c3f640389160aa73a299aed8c512">sigc::bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#a52abd6d1eb7dd0919ecb6d3a667b0e18">sigc::bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#a72dab40d6161daa1ad1655a03e5a5aa4">sigc::bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#abbd560d8331fbab5cd8a08afd756c8fc">sigc::bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#aec37eae62ba95f04b55dd6c55c6161c1">sigc::bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor0.html#ae64f4c6596667228376947a38c4a8bb7">sigc::bound_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor1.html#a95ae2c4525d8218569b68bbb3effbadf">sigc::bound_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor2.html#a423780eab9a560771ec3266ea0693117">sigc::bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor3.html#ae05cea0cbd3345abc624e545422bb47a">sigc::bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor4.html#aa9a90c28652fb499438e757cdc6f3be7">sigc::bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor5.html#a477578c56471258d6eaefb45713dbae8">sigc::bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor6.html#a8aced07018e8f32dcc4339ce26a0e924">sigc::bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor7.html#a03e799b2af9cdc19c76e81d0bcb843ad">sigc::bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html#abc4357df8d4458326135e23965ba5871">sigc::bound_volatile_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html#a09b9ac461833030fae01249b50e5984c">sigc::bound_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#a80858a8bbb89469136b8e476d0bae0e6">sigc::bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#a01d01f9945bd93e227403cdbb8271e2a">sigc::bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#a4bb276cfe8c35645f166cde087f5d17f">sigc::bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#ae17c42b74b72c74f3a7e4d5faadaa761">sigc::bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#a64c4455bc351be0f2b42dc28b03baeb9">sigc::bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#a32b6c9b9aaa1e750217fc1f9d9e4b2df">sigc::bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>operator bool()
+: <a class="el" href="structsigc_1_1connection.html#a93215e1ea86c5fd0a465b2c4dba1257e">sigc::connection</a>
+, <a class="el" href="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9">sigc::slot_base</a>
+</li>
+<li>operator const T_type &()
+: <a class="el" href="structsigc_1_1const__reference__wrapper.html#a2cf7a981855668dfb69e98cfaa6eb779">sigc::const_reference_wrapper< T_type ></a>
+</li>
+<li>operator T_type &()
+: <a class="el" href="structsigc_1_1reference__wrapper.html#ae0b2f512b6a2555b489ed9dd229efc1c">sigc::reference_wrapper< T_type ></a>
+</li>
+<li>operator!=()
+: <a class="el" href="structsigc_1_1slot__const__iterator.html#a0139736ee01df37af11f3551d76a2b53">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#a880c8929759eca2fc7fb55cb0c813c55">sigc::slot_iterator< T_slot ></a>
+</li>
+<li>operator()()
+: <a class="el" href="structsigc_1_1adaptor__functor.html#a5be4edc8ea900c6454cb024836b9f655">sigc::adaptor_functor< T_functor ></a>
+, <a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a8fb31d32467dfe99815ca39b766cafac">sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a5bd5dd13ef2cd495cfd23b8d0f7cffbd">sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="structsigc_1_1bind__return__functor.html#a1b9d2dc672b8dfd7c769bbcedf25d8aa">sigc::bind_return_functor< T_return, T_functor ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor0.html#a7949abb2e0a675ab7faccf4b0c2b5480">sigc::bound_const_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor1.html#a4ba51a05a053caf20d9306efb0f05791">sigc::bound_const_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor2.html#a00df32df2a5bafc0adb39da243ad3a3d">sigc::bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor3.html#aabad5390e5b2671de1b9fbba7bf1cda6">sigc::bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a4db87f79d355f2ca4f5ff20d47c35ee3">sigc::bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a89a861b0925989a0e845399443eee20a">sigc::bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a6bc7018118bbf55444f4d9250cf3ce65">sigc::bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor7.html#a941b925ad1f628cde49bb268be8daf4a">sigc::bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html#abbe8bbaa0d3d7318046be146fe6fda03">sigc::bound_const_volatile_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html#a0c520be9f25daa56ca9aba061edb7e77">sigc::bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a434acb850963a28b1a5a4662fad2b5d5">sigc::bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#af14d93c72657777d2257e3db60f20a01">sigc::bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#ac1593becd15c2704535c9b50482503f9">sigc::bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#a7f70def3a438e6735b67f669c8fc107a">sigc::bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#a9cd3a5dd70008fe70d17712cfee0f470">sigc::bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#a8fe1055d39082226d8acb3201b7b5ce7">sigc::bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor0.html#a8f0ea7caa1c5858b44ebdb0bcf4ba74a">sigc::bound_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor1.html#af9d43a802f122d38d264b3f662bcfe43">sigc::bound_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor2.html#a09d48d61cc092e3f12c8ac4df4449596">sigc::bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor3.html#aa61ed1a1c920069032ffd5427d24a771">sigc::bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor4.html#a0a9d2fb52ef15ae8d4e56238217c0539">sigc::bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor5.html#aa1de6366cd9e5f0ea037287438a8072f">sigc::bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor6.html#ad44376814c73959398026d4e0df3d401">sigc::bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor7.html#ab0c379b445a5655f55f8260c699e7053">sigc::bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html#a5726bcc0d34cff2356976bc586d36b44">sigc::bound_volatile_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html#a989556175b19d8e13c34727f231228ad">sigc::bound_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#a5a93614f492dacd37dd1cfd94cc033b3">sigc::bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#af5b4934a8e75fd7c32d41a989ec67f66">sigc::bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#a22702ad82b54c77d93fb6d0481896d8f">sigc::bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#aaf0765f195ee2efef0536dfb854af9e4">sigc::bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#aa8aa3006bba7344c630f6f8adb3507d5">sigc::bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#ad1ab1d5cf45600c5369a0a119a5a89ad">sigc::bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="structsigc_1_1compose1__functor.html#ab32178c24587037b5ae30b8b807f5a35">sigc::compose1_functor< T_setter, T_getter ></a>
+, <a class="el" href="structsigc_1_1compose2__functor.html#adfcd11f81cefb39743d9467d21510c53">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor0.html#abcc08c39943577648dac107692e5b34a">sigc::const_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor1.html#a3a575262ae2d62c39c52280017956a95">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor2.html#aafbf14880952214525553f4b419bf5c6">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor3.html#aa123c4fb39116ca1a28896cfd029b1de">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor4.html#a25b73f70e0cb8771a6fc8dd1ad521795">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor5.html#aaceffe6505aed22dd5af369231914965">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor6.html#a8657b806cb2eeb7e43f0a09f6556c514">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor7.html#a53f19248e5b61460759d7cdbf41ca21b">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#adfd64d64707c012329915edf19190772">sigc::const_volatile_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#a715b1d5c56a537cbd397875e8eba532d">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#a467a45cf9bc54bed0f3c5bade3329067">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a4af918f707067763bb2031d8758991d5">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a7cd0900e7e3c8523503e037e7c696f5d">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a8d74b334440d1c9add3a358cd1913b11">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#a5cf522fd8072a8f77e56cae87d65892f">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a9cb200c4d7a95edf269ede2b9c7ab060">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="structsigc_1_1exception__catch__functor.html#a5bb82bbe1b0491cd5c53680eb5cd6b03">sigc::exception_catch_functor< T_functor, T_catcher, T_return ></a>
+, <a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a4c24ffa31304c0647b0d29cba07ffe3a">sigc::exception_catch_functor< T_functor, T_catcher, void ></a>
+, <a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a5390f82ac4049f2a22ef1f4896a508dd">sigc::hide_functor< 0, T_functor ></a>
+, <a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a4c9d0e81c0dacb65443b810ba90f81b7">sigc::hide_functor<-1, T_functor ></a>
+, <a class="el" href="classsigc_1_1mem__functor0.html#a51d5213c9d41b51e3b8cca705bd801cc">sigc::mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1mem__functor1.html#a55a370a320def89e80aa37141c101c98">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1mem__functor2.html#ad5d0f74803537d1ed8b9678ac2da57d5">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1mem__functor3.html#ae7496f451661d60b287d528a7cfcaf82">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1mem__functor4.html#aef140dac7b4876793fac8a006aad0a62">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1mem__functor5.html#af1ce121edd0248d104f95e239af683bd">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1mem__functor6.html#a4a322216c1783eb8ad7f63972b3a1164">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1mem__functor7.html#ad8e9031dc12742265d834a5529b1f00d">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1pointer__functor0.html#a56db821303c19ec3345679d80d6ef96e">sigc::pointer_functor0< T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor1.html#a3c978e35c107326078f3e33afcdd1235">sigc::pointer_functor1< T_arg1, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor2.html#af3d1d778be1730e170c42c52511d6926">sigc::pointer_functor2< T_arg1, T_arg2, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor3.html#adf560c1e583b2216bba4de3027e3a05e">sigc::pointer_functor3< T_arg1, T_arg2, T_arg3, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor4.html#a42875d789a30fb04395dbef76d720989">sigc::pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor5.html#aa2f399d3f76e802670c8a08ede82c40c">sigc::pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor6.html#ac35109048b7360e1436e2b4e3a53d1cf">sigc::pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor7.html#a564941861ee4b84b9b61a1f247f0cfa1">sigc::pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return ></a>
+, <a class="el" href="structsigc_1_1retype__functor.html#a7b869ff5f806496f7d99f5ae68823291">sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 ></a>
+, <a class="el" href="structsigc_1_1retype__return__functor.html#a0bcbf84c24c2195626bf4e6a2d1353b1">sigc::retype_return_functor< T_return, T_functor ></a>
+, <a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#adb392f4717b522668eb5236dbaf48e68">sigc::retype_return_functor< void, T_functor ></a>
+, <a class="el" href="classsigc_1_1signal0.html#a2dd3042c0681542ed6f2de5840f713a1">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#a828907c11f5c18d9522e5d5139484620">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#ac8b73c0624273b8dae819255961ea6a3">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#aa7ae5338d6a883a28c61ff202e43547f">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#a8523a4d47c3a6469fcc50da9977afdb8">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#a7a5bb7b92f49e99354caf50bfef16907">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#affec011fd6e9605f10e50fdd4db424d8">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#ac6fd43215c8f19082402387359330071">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1slot0.html#afa926436a4b0734f0adc2a485ccfe36a">sigc::slot0< T_return ></a>
+, <a class="el" href="classsigc_1_1slot1.html#ae9082daf31fdbb57da71e8c38a9ae1ab">sigc::slot1< T_return, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1slot2.html#aa2abda2a910db19bbb7a2a08d867e358">sigc::slot2< T_return, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1slot3.html#addbe340b1f547308035707236e690e66">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1slot4.html#a02b0d861a47418b9dbf73ab7db67b0a9">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1slot5.html#a3f2d9fa2c9747d6c7fc329213446c71d">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1slot6.html#ac2d6449f2928138c434c474050c7c192">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#a4038d1a1c7a34bbb344b61a8f43c23f6">sigc::slot< T_return(T_arg...)></a>
+, <a class="el" href="classsigc_1_1track__obj__functor1.html#a3da19bfd10f0b9f84ae83b06f8211ae6">sigc::track_obj_functor1< T_functor, T_obj1 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor0.html#af627ef410fac7ec5d2ee842d8f89fe51">sigc::volatile_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor1.html#a69185452103c51af81b78e95504eb95c">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor2.html#ac4c64a4812347e17744e33e5e37775d7">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor3.html#a39944451f3bb1538828e45b66f082ea0">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor4.html#a86a0e482790971e3674b9ba488e10127">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor5.html#ab6449c487e42fc9810c0f8d5a6cc243f">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor6.html#a00320a319413753f756304a8db0fbf51">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor7.html#a05ed4811582f583a1a1e11b1a8951a21">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>operator*()
+: <a class="el" href="structsigc_1_1slot__const__iterator.html#a37c9a5d5bba252e41a628bd1c87fd883">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#aa01dddd6f7b4e1a726a55cd1d430f398">sigc::slot_iterator< T_slot ></a>
+</li>
+<li>operator++()
+: <a class="el" href="structsigc_1_1slot__const__iterator.html#aed166d716b032a781d2169c919cefdc9">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#af5a3b852c1c6e8f69c41f64a17204758">sigc::slot_iterator< T_slot ></a>
+</li>
+<li>operator--()
+: <a class="el" href="structsigc_1_1slot__const__iterator.html#a1c1d7d7798914c80d6a60d87c4b24c0a">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#a8aeef4e41dc0930beaa8d6a37b27775c">sigc::slot_iterator< T_slot ></a>
+</li>
+<li>operator->()
+: <a class="el" href="structsigc_1_1slot__const__iterator.html#afd0ff56e0779787da2c7dfdb0ef4630c">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#a0a77bd2eccf05cecbdf3b690c5301540">sigc::slot_iterator< T_slot ></a>
+</li>
+<li>operator=()
+: <a class="el" href="structsigc_1_1connection.html#a016094b53bafdc9ce593febb68cb00a5">sigc::connection</a>
+, <a class="el" href="classsigc_1_1signal0.html#a693aa3743236012416349bfac56d31b6">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#a29cd06bf91f96f11c5f29237b8afbb71">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#abeb05d9a2b40882bad753fccad6522be">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#a0c398a25051e920bc4338f35b4bf7df6">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#a05908db9c09a9c513529cd8b2106f913">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#a2c3d9a6d8b499da389672f44f8044ce6">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#ad7a4ab249b17bffccbfe441aa1420dd9">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#af8a93a4c8fb0b78fa6578e7dc95f5751">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal.html#adeccc0c1c698e33c1da15c7f667f2a23">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4.html#acbc101f4d7b4e460929593bac336957f">sigc::signal< T_return()></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html#a20f539ef645cba235c03d8d13f221ae5">sigc::signal< T_return(T_arg1)></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html#abdcf63e52e05fd88654a7e688abd57b1">sigc::signal< T_return(T_arg1, T_arg2)></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html#aee5b61e3b98fe989e78f96d2117d74d1">sigc::signal< T_return(T_arg1, T_arg2, T_arg3)></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html#a838a70902714d4cb065ea1bf22e0f376">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html#a95b7d55776c477cae58859f01a043d6e">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html#ad93fa9a04fa76e3133adb4361981c5cd">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html#a8fe96aaacf6a2d0780887623a6f2b15a">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a9603080b1a0c76e32eb6859594c59665">sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a418026bd364a6b5510f0227f497b9473">sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ab610351f5cdf9f332d9a1003a0481ab3">sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a8a0166f439840b854ab3253fa831bb03">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a84ee7d648bf622ec496127ceec819946">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a05a22fca63088154ba5c15b221e30760">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a6cbe2b81b53c97bc39c26bbedcb070f1">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a>
+, <a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">sigc::signal_base</a>
+, <a class="el" href="classsigc_1_1slot0.html#a49bba0540dcc76fb19e49d19a1acd563">sigc::slot0< T_return ></a>
+, <a class="el" href="classsigc_1_1slot1.html#a2e0d65cfc434718b6c5f7d7135ac384e">sigc::slot1< T_return, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1slot2.html#aeda5a84c674376aa0800a0bf876bb5fa">sigc::slot2< T_return, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1slot3.html#ac40a1cefaf9c356a691dfea6819094b8">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1slot4.html#ac2fb7f8ae312ced5b7436f0a0d062132">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1slot5.html#a24d22be7be827080b34109c625bad7fd">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1slot6.html#a7d13ed520a19d287719bd24050b7d8a2">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1slot7.html#af6bf09a0b3c09245257af113e70269d2">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1slot.html#ac7beb1ab973b6cd124d2cdea3f0c1e0c">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#a34e1ec92ebbc3ee4dbc8acdeb525c12c">sigc::slot< T_return(T_arg...)></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#aba4c957436ba517b8b21a58e75ef9253">sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a88a00e43c5ed084441655b2f9e32c621">sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a98c52bf9ca78dc5f940ec5f5ca466bd9">sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a355a28cb253c5a14fb36574316f40e3b">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#aebe6238dace66568d5135f1a7d41e8d1">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a3195ba5b04503a37525bf2142c704f70">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#ace5ff8e4e75675985f148a3d2af0ce64">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a>
+, <a class="el" href="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad">sigc::slot_base</a>
+, <a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable</a>
+</li>
+<li>operator==()
+: <a class="el" href="structsigc_1_1slot__const__iterator.html#af88c3fcadb7ce415fcad4bd5dafad087">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#af2b4e16f15258f6cd98f8049afd0b88d">sigc::slot_iterator< T_slot ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all class members with links to the classes they belong to:</div>
+
+<h3><a id="index_p"></a>- p -</h3><ul>
+<li>parent_type
+: <a class="el" href="classsigc_1_1slot.html#a1966941e9654adfb3af4b994fd18a7f3">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a9937c7fbdb8be4e387fddcebf328fa41">sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a2b6b5b8590577c765c7a32f7e619250a">sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a867e776b644ca32a703866a424ae3ba5">sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#adbafac5ab39a4a017406ac9587c9511c">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a704393344c1ba2f6bdda9b466bb81af1">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a013f4139332e23166f7db3be6da4ba91">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a9c9028da9fc75a10c6c396673159d471">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a>
+</li>
+<li>pass
+: <a class="el" href="structsigc_1_1type__trait.html#aebfa426334f8de7b93031de35d2495e3">sigc::type_trait< T_type ></a>
+, <a class="el" href="structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html#a7b9cd2a3e6e7cf986e4e25e05c665c73">sigc::type_trait< const T_type & ></a>
+, <a class="el" href="structsigc_1_1type__trait_3_01T__type_01_6_01_4.html#a1b24e79fed94df3fc0e7574e0ae1c991">sigc::type_trait< T_type & ></a>
+, <a class="el" href="structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html#abfd06dd56be6fda2436e9e15acb1fc72">sigc::type_trait< T_type[N]></a>
+, <a class="el" href="structsigc_1_1type__trait_3_01void_01_4.html#ab5d97b4ec126f3afeaf67e9a6b05b0be">sigc::type_trait< void ></a>
+</li>
+<li>pointer
+: <a class="el" href="structsigc_1_1slot__const__iterator.html#a28f3f0d2ac11dd8805d75682d8f38022">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#afb36f2add6064e0d7e7ae63ee2ddcde9">sigc::slot_iterator< T_slot ></a>
+</li>
+<li>pointer_functor0()
+: <a class="el" href="classsigc_1_1pointer__functor0.html#afdb67f682e7b9190f646eed879dcfbe4">sigc::pointer_functor0< T_return ></a>
+</li>
+<li>pointer_functor1()
+: <a class="el" href="classsigc_1_1pointer__functor1.html#a8ab0c5b707dc41a821c63769344db2cb">sigc::pointer_functor1< T_arg1, T_return ></a>
+</li>
+<li>pointer_functor2()
+: <a class="el" href="classsigc_1_1pointer__functor2.html#a2977aa1d72f5f0fd6c778b60ad791b9c">sigc::pointer_functor2< T_arg1, T_arg2, T_return ></a>
+</li>
+<li>pointer_functor3()
+: <a class="el" href="classsigc_1_1pointer__functor3.html#a1a4909d1444e4456a89eb5852933d1cc">sigc::pointer_functor3< T_arg1, T_arg2, T_arg3, T_return ></a>
+</li>
+<li>pointer_functor4()
+: <a class="el" href="classsigc_1_1pointer__functor4.html#ab8e3bf143e71c5ffe8f155ace0f895a8">sigc::pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return ></a>
+</li>
+<li>pointer_functor5()
+: <a class="el" href="classsigc_1_1pointer__functor5.html#aa86bb74ff5e188f8f6497b7e73621cdd">sigc::pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return ></a>
+</li>
+<li>pointer_functor6()
+: <a class="el" href="classsigc_1_1pointer__functor6.html#a26551fa703a65a9a14190c7579a3b77d">sigc::pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return ></a>
+</li>
+<li>pointer_functor7()
+: <a class="el" href="classsigc_1_1pointer__functor7.html#a1268abfa3437c0977517dd4cd0548080">sigc::pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return ></a>
+</li>
+<li>pop_back()
+: <a class="el" href="structsigc_1_1slot__list.html#abb28f82ef0cbc78a86a4becd61b0c9ff">sigc::slot_list< T_slot ></a>
+</li>
+<li>pop_front()
+: <a class="el" href="structsigc_1_1slot__list.html#a9244005ecc265b07b7f451e63662686e">sigc::slot_list< T_slot ></a>
+</li>
+<li>push_back()
+: <a class="el" href="structsigc_1_1slot__list.html#a5c7401657a6020c14616e62b20949de8">sigc::slot_list< T_slot ></a>
+</li>
+<li>push_front()
+: <a class="el" href="structsigc_1_1slot__list.html#a5bb241c13cb363825f787ecd244ebf7d">sigc::slot_list< T_slot ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all class members with links to the classes they belong to:</div>
+
+<h3><a id="index_r"></a>- r -</h3><ul>
+<li>rbegin()
+: <a class="el" href="structsigc_1_1slot__list.html#a1d4d33c9ac07a6012332d89100e8fbeb">sigc::slot_list< T_slot ></a>
+</li>
+<li>reference
+: <a class="el" href="structsigc_1_1slot__const__iterator.html#a8300967b4b29096e7ad0b96db04e095a">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#aa3e69a557b73d817a1951af1b1767632">sigc::slot_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__list.html#ab0f2255639f24ff02d45f97994bc0e11">sigc::slot_list< T_slot ></a>
+</li>
+<li>reference_wrapper()
+: <a class="el" href="structsigc_1_1reference__wrapper.html#a05dfcad06f2af395c5e2daa9600d455a">sigc::reference_wrapper< T_type ></a>
+</li>
+<li>remove_destroy_notify_callback()
+: <a class="el" href="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c">sigc::slot_base</a>
+, <a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">sigc::trackable</a>
+</li>
+<li>rend()
+: <a class="el" href="structsigc_1_1slot__list.html#a805f74b49477673660b039576cbec20f">sigc::slot_list< T_slot ></a>
+</li>
+<li>rep_
+: <a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">sigc::slot_base</a>
+</li>
+<li>result_type
+: <a class="el" href="structsigc_1_1adaptor__functor.html#adc1e7ebba9db294494c62666e10b719b">sigc::adaptor_functor< T_functor ></a>
+, <a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html#a512a6d201bdd43574a2df993b3b85d0e">sigc::adaptor_trait< T_functor, false ></a>
+, <a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html#a6b83ed91f53a25e7002546a2835457b3">sigc::adaptor_trait< T_functor, true ></a>
+, <a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">sigc::adapts< T_functor ></a>
+, <a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a1c6d091ffd70c23930cf6e2b9042d466">sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#abd1e51093bf7d4428e443c2e6704bed9">sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="structsigc_1_1bind__return__functor.html#a4fe6cb8d80573ae7abe934ba54879592">sigc::bind_return_functor< T_return, T_functor ></a>
+, <a class="el" href="structsigc_1_1compose1__functor.html#ab096c0a388f877d97b3812f2fcc813f9">sigc::compose1_functor< T_setter, T_getter ></a>
+, <a class="el" href="structsigc_1_1compose2__functor.html#a78ccb07f23696a452df9f61308885542">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor0.html#a553cd4d85524b5deea445b67773527bf">sigc::const_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor1.html#a8ba6a6565b8a29812e266aa4e5261a2d">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor2.html#a5eaa5f2ab10ad755c89ff5b09c1e281d">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor3.html#ae67fd219e64f81359640873d30123c9d">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor4.html#a78069750e64446199d91c0682b0915cc">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor5.html#a9d952d52dade789bc38953c4c83fb425">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor6.html#adf81aebfa633d0bf14a0d3f5e9688561">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor7.html#a724b8b210493e0d3cf06b5a393b91546">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#ab8e419ef5ad21d6230a306cd7d910df9">sigc::const_volatile_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#adeaf82cc2aff607efe2a51945d6b8565">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#a0d143bb32627f7a0c17270321df8145f">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#ad2056f73eed4664ff41f5e673a2276f0">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a8e38a0816627c7ad4fd48278d287f863">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a42d6cd140b98358c1d12c90b975ad2b1">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#a9f866db08b59a0960875f7608a0c93f0">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a25cb7e6ed71406c5b91ab2696ad8e623">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="structsigc_1_1exception__catch__functor.html#a498f5575ae283594cfe03288fab54fdf">sigc::exception_catch_functor< T_functor, T_catcher, T_return ></a>
+, <a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a06506e0d4da26682740b7f4f9aec80d5">sigc::exception_catch_functor< T_functor, T_catcher, void ></a>
+, <a class="el" href="structsigc_1_1functor__trait.html#af1324bf0d3cec3d1f2e39e932b228d6d">sigc::functor_trait< T_functor, I_derives_functor_base, I_can_use_decltype ></a>
+, <a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#af5b5ee49bb277471b5bc8e3769d0dcb7">sigc::hide_functor< 0, T_functor ></a>
+, <a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a72ea0ce5ad7cf4f9e0e7b160d830c5a4">sigc::hide_functor<-1, T_functor ></a>
+, <a class="el" href="classsigc_1_1mem__functor0.html#aa679f73c7b786540686c110628a71dde">sigc::mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1mem__functor1.html#a7c7ab28530e2f678eae87772253df709">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1mem__functor2.html#a9080e942d35d226ea6f9dda097342f07">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1mem__functor3.html#af620103fa36aa86fb539843f7f730e01">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1mem__functor4.html#a79bf0a3c25dbe6eb07829ee55ce5d664">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1mem__functor5.html#a3e0587ce338328d42f44c4e5f79be6ed">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1mem__functor6.html#af80425ff57ca2115cba771c275f49e36">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1mem__functor7.html#a967b5f6572e988ea0833818b993745f9">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1pointer__functor0.html#af44316e53e33b4184ca151b6b11c70e5">sigc::pointer_functor0< T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor1.html#a4080910d23a74b102a123838fa93e90b">sigc::pointer_functor1< T_arg1, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor2.html#a297b784eb0cea07b364c854e5dd5f864">sigc::pointer_functor2< T_arg1, T_arg2, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor3.html#a2a0ed29803c02cc62fcc6497f83f88bf">sigc::pointer_functor3< T_arg1, T_arg2, T_arg3, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor4.html#a787f8ea1c15d7bfab7643081a408401c">sigc::pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor5.html#a00dcbec8a920ea784e3210743c77855b">sigc::pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor6.html#a9fd7af745ebad4d59f67e0f60fb395e0">sigc::pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor7.html#a41613e64e2b96656b85aa9eefa35aa91">sigc::pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return ></a>
+, <a class="el" href="structsigc_1_1retype__functor.html#a1a594553d0312ca12e1009d179af0dbe">sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 ></a>
+, <a class="el" href="structsigc_1_1retype__return__functor.html#aa8421dc266ad653de395e7d01e631fdc">sigc::retype_return_functor< T_return, T_functor ></a>
+, <a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#a64bccc59fc20fdf0fd80281597d350b2">sigc::retype_return_functor< void, T_functor ></a>
+, <a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1slot0.html#aca0c967b605e09d5a87015d95e93d4f7">sigc::slot0< T_return ></a>
+, <a class="el" href="classsigc_1_1slot1.html#ab4991fe5d80761ddab482fda9ebe6d17">sigc::slot1< T_return, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1slot2.html#a0bb920e3d5628c3d01a4337a2a8a97fc">sigc::slot2< T_return, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1slot3.html#a69cca26f164c63de6ffa70a3806fb936">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1slot4.html#a3f6b5b11385536c1c199ca29468c638a">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1slot5.html#aac50a6486dddcac3a42022a6f2189f09">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1slot6.html#a8dae48d6160e0f917f545eb10950a9bf">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1slot7.html#a06a374d3304636cb48fed29542dc851f">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#af593e79280c004b6ef8f4722953df0c4">sigc::slot< T_return(T_arg...)></a>
+, <a class="el" href="classsigc_1_1track__obj__functor1.html#a17ad87a124cb6fafc37a2d573d47f222">sigc::track_obj_functor1< T_functor, T_obj1 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor0.html#a41fbd67d6bbde0818b880f08f6295396">sigc::volatile_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor1.html#a3bcbf6ae6e950d35e4ac7b33fa066877">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor2.html#a67719071ed0eacd994fa6fe300cfb24d">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor3.html#a229fe43026e97bbcf80215ea8e9fa828">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor4.html#a58dd95fa47c02a9ba6340682c7dbbcb0">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor5.html#ab647ea2e44db475cc2d4bae8be842127">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor6.html#a1ce192c145ec5af4c826ccb2619cf002">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor7.html#a4762374376dcb7b11c77372edab78823">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>ret_value_
+: <a class="el" href="structsigc_1_1bind__return__functor.html#aa7b8287c19d98cec75a7e64a9464772e">sigc::bind_return_functor< T_return, T_functor ></a>
+</li>
+<li>retype_functor()
+: <a class="el" href="structsigc_1_1retype__functor.html#a30f35ce3d25b7fd571fbd3ef730de225">sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 ></a>
+</li>
+<li>retype_return_functor()
+: <a class="el" href="structsigc_1_1retype__return__functor.html#aa9546db86a6d1cfa7224a3a0cbad4827">sigc::retype_return_functor< T_return, T_functor ></a>
+, <a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#a720e802de29a72d1e15626b1719844bc">sigc::retype_return_functor< void, T_functor ></a>
+</li>
+<li>reverse_iterator
+: <a class="el" href="classsigc_1_1signal0.html#a1d9c390974304392ed12ee81543ab997">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#ab0443049aa736d88770d0f534600b2bc">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#a6710759bdeb8e626fc09d8c448e6613f">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#acc453f0d5fc7f277494b2d6e737f6f68">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#a1395da7d3283b0166af135193a4047c8">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#ab684cb9920d0f7949f28c03d50b58275">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#a79b741b3f0def8f52fc185ad50b60673">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#a59c9c9fee7a98528839df592241351a9">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+, <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">sigc::slot_list< T_slot ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all class members with links to the classes they belong to:</div>
+
+<h3><a id="index_s"></a>- s -</h3><ul>
+<li>set_parent()
+: <a class="el" href="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9">sigc::slot_base</a>
+</li>
+<li>setter_type
+: <a class="el" href="structsigc_1_1compose1__functor.html#a86a8bc8f4926f7bb91ef362fff03a25e">sigc::compose1_functor< T_setter, T_getter ></a>
+, <a class="el" href="structsigc_1_1compose2__functor.html#ac3d7308c702df7378af1635281d5f7b8">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a>
+</li>
+<li>signal()
+: <a class="el" href="classsigc_1_1signal.html#a50432d1aebfbee5ef17a3f434d0c50bf">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4.html#aba571147db7b805fad8da3c0c82fea0b">sigc::signal< T_return()></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html#acc30f0949e699fbff85d341162298761">sigc::signal< T_return(T_arg1)></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html#acc41707d3187fe1ac6bb9180f82428a7">sigc::signal< T_return(T_arg1, T_arg2)></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html#ac22b59e41db40b6cbe6ac4b71d048170">sigc::signal< T_return(T_arg1, T_arg2, T_arg3)></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html#a8d26e7db0ca474d71736c778e0264f4c">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html#a7006442d66ee8f812ffdff15cd5694a3">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html#a16f865ba75270a1808ed8f3a37e53a48">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html#a5595334118f67137ded1af1720743da8">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a69bd320a61ade13046ae3ed20498ab83">sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a7561df6caf1f508eff71f035db8260c1">sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a3ad9be2894fd3f78bfde9488207ff502">sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a3866d625025ecae063d59e81f86ec836">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a51f9443b48b006a65114bdd18d13cd4b">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a5e64ba037f3567ab5dbb49811a447b2c">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a>
+, <a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#aa070e4d37a8a06ef9fc02256d236472c">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a>
+</li>
+<li>signal0()
+: <a class="el" href="classsigc_1_1signal0.html#a2fb24e11a8f645e5122646ea2b4a5d2f">sigc::signal0< T_return, T_accumulator ></a>
+</li>
+<li>signal1()
+: <a class="el" href="classsigc_1_1signal1.html#aba62d8d0b9591bcfd728f8ae8a22d600">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+</li>
+<li>signal2()
+: <a class="el" href="classsigc_1_1signal2.html#a47aba9b19bc2bef0be7183022567e3ea">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+</li>
+<li>signal3()
+: <a class="el" href="classsigc_1_1signal3.html#a52731959f272612fd6abfe8850c5c8cf">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+</li>
+<li>signal4()
+: <a class="el" href="classsigc_1_1signal4.html#a2d469f516a9edac2b20d7f6cf46e821a">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+</li>
+<li>signal5()
+: <a class="el" href="classsigc_1_1signal5.html#af717d1a6fd8612da84dce33fe6640b7a">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+</li>
+<li>signal6()
+: <a class="el" href="classsigc_1_1signal6.html#af7f529bbd9cf26d468ed18426b9b51ea">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+</li>
+<li>signal7()
+: <a class="el" href="classsigc_1_1signal7.html#a5a5893dd4f97d77b7945819f5ada2aee">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+</li>
+<li>signal_base()
+: <a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">sigc::signal_base</a>
+</li>
+<li>size()
+: <a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">sigc::signal_base</a>
+</li>
+<li>size_type
+: <a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">sigc::signal_base</a>
+, <a class="el" href="structsigc_1_1slot__const__iterator.html#adb1eeabfa619cbd9565aa0f9429ca5ed">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#a1dd8ea0a80b5bb0f936833a1c2e363ed">sigc::slot_iterator< T_slot ></a>
+</li>
+<li>slot()
+: <a class="el" href="classsigc_1_1slot.html#af643a8ef3eafd24f738224bbd6056fa3">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#ae7d852d9ac2c9a6a37564a0f4aed3872">sigc::slot< T_return(T_arg...)></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#abdb48282bb8b1b5404fcea6474eca5a5">sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ad34e10be904557368c241f53e972c8e7">sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ad034a7e1a5344031ee9764c063054814">sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a508b21923e1ef3d7d689984132d89360">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a4e1e1ecd839575d1d928325f8882fbfb">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a81c9e625279217aee1ae00696927c39e">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a8be1480e392dcaa57d47e1c2a132edd4">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a>
+</li>
+<li>slot0()
+: <a class="el" href="classsigc_1_1slot0.html#a83a247c06b93ef644bdfe0bf119929c0">sigc::slot0< T_return ></a>
+</li>
+<li>slot1()
+: <a class="el" href="classsigc_1_1slot1.html#aa8ac5eadba778c11a424e255889e67f6">sigc::slot1< T_return, T_arg1 ></a>
+</li>
+<li>slot2()
+: <a class="el" href="classsigc_1_1slot2.html#a3f9f6cf199bbb40011eca25eb9da67c2">sigc::slot2< T_return, T_arg1, T_arg2 ></a>
+</li>
+<li>slot3()
+: <a class="el" href="classsigc_1_1slot3.html#ac477d74beed45b2b3e26d19b083147ad">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a>
+</li>
+<li>slot4()
+: <a class="el" href="classsigc_1_1slot4.html#a4b8ef0494eea86c0d787486ce121db91">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+</li>
+<li>slot5()
+: <a class="el" href="classsigc_1_1slot5.html#a7548f0d175acd8296064c9bc6d76ea88">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+</li>
+<li>slot6()
+: <a class="el" href="classsigc_1_1slot6.html#a3c763adcaa8b9c34c808ef0f15b1fc48">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+</li>
+<li>slot7()
+: <a class="el" href="classsigc_1_1slot7.html#a69a267bb61931f4ea039048d3221517c">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>slot_base()
+: <a class="el" href="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1">sigc::slot_base</a>
+</li>
+<li>slot_const_iterator()
+: <a class="el" href="structsigc_1_1slot__const__iterator.html#a2b9e80b87a3400bb6f794c07f90d2d47">sigc::slot_const_iterator< T_slot ></a>
+</li>
+<li>slot_iterator()
+: <a class="el" href="structsigc_1_1slot__iterator.html#a82d4023ad9dc38dcde4cae6bf65cd8c8">sigc::slot_iterator< T_slot ></a>
+</li>
+<li>slot_list()
+: <a class="el" href="structsigc_1_1slot__list.html#a5baac8e52fda5f6fc4fa31bed67077e3">sigc::slot_list< T_slot ></a>
+</li>
+<li>slot_list_type
+: <a class="el" href="classsigc_1_1signal0.html#add195c1c738ee8efe10294f21d258b77">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#a5fadeb350140d6aaf560b217e7e7c4b4">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#af31262f54dfb2a97540de9c4a1fc5726">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#a3bc0616e7ac933e702a889a2a84e92d4">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#a0ad0f56a43825c6d77d36dd2f06ef828">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#a4c79ab227fc3b31b990e925636f7788e">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#a0e4fea9bd1ed35f9d60bbc26c4fae007">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+</li>
+<li>slot_type
+: <a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+, <a class="el" href="structsigc_1_1slot__const__iterator.html#ae377905cad9a91ca23d09877c72d82cd">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#af7a0ed93fca0064021d77275305e04a9">sigc::slot_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__list.html#af769819a62b19adb888eb231709e894f">sigc::slot_list< T_slot ></a>
+</li>
+<li>slots()
+: <a class="el" href="classsigc_1_1signal0.html#a5576113ddfd6b92a96f86072262307f9">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#a7777660b21fef2a6941c7dff23964604">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#ac28b0205aa1e60cc5ce062d4d8545323">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#ab9606b708078956a758b81503f956bee">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#ae490f1a6802c40a4c3b12e1580520c88">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#ad6a4ae2a214d8710be6e36bb425587fc">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#af44115a7bfa4586fc5312259a1df9567">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#a68153d9079b4881352113079cd6216f7">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all class members with links to the classes they belong to:</div>
+
+<h3><a id="index_t"></a>- t -</h3><ul>
+<li>take
+: <a class="el" href="structsigc_1_1type__trait.html#a191a797ea6e2d851287b8a87b6305157">sigc::type_trait< T_type ></a>
+, <a class="el" href="structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html#a2c3a2a62adee114867045a7f77096435">sigc::type_trait< const T_type & ></a>
+, <a class="el" href="structsigc_1_1type__trait_3_01T__type_01_6_01_4.html#a604c7ad05de42e3f9d28ab45c8d865b5">sigc::type_trait< T_type & ></a>
+, <a class="el" href="structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html#a9cb9e2faaa68a89ef1a74b8b7c98d81e">sigc::type_trait< T_type[N]></a>
+, <a class="el" href="structsigc_1_1type__trait_3_01void_01_4.html#a40d187392469ee48d24838ef38531b90">sigc::type_trait< void ></a>
+</li>
+<li>test()
+: <a class="el" href="structsigc_1_1deduce__result__type.html#a46816d343f0924170208d220b7e599f4">sigc::deduce_result_type< T_functor, T_args ></a>
+</li>
+<li>track_obj_functor1()
+: <a class="el" href="classsigc_1_1track__obj__functor1.html#a1bcc00d3b665af8f40fa18936fab5304">sigc::track_obj_functor1< T_functor, T_obj1 ></a>
+</li>
+<li>track_obj_functor2()
+: <a class="el" href="classsigc_1_1track__obj__functor2.html#ae12b4c85e92a265c011fccf090fa6947">sigc::track_obj_functor2< T_functor, T_obj1, T_obj2 ></a>
+</li>
+<li>track_obj_functor3()
+: <a class="el" href="classsigc_1_1track__obj__functor3.html#add83622dc2ad7cd561d2c59768eea45a">sigc::track_obj_functor3< T_functor, T_obj1, T_obj2, T_obj3 ></a>
+</li>
+<li>track_obj_functor4()
+: <a class="el" href="classsigc_1_1track__obj__functor4.html#a29f48beae82cf67da9b70a51da35a2e9">sigc::track_obj_functor4< T_functor, T_obj1, T_obj2, T_obj3, T_obj4 ></a>
+</li>
+<li>track_obj_functor5()
+: <a class="el" href="classsigc_1_1track__obj__functor5.html#a1f0481289e8c48acc4cc6561c8f0c8b6">sigc::track_obj_functor5< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5 ></a>
+</li>
+<li>track_obj_functor6()
+: <a class="el" href="classsigc_1_1track__obj__functor6.html#a70b36db3f8cafb77c48269c3e4c68714">sigc::track_obj_functor6< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6 ></a>
+</li>
+<li>track_obj_functor7()
+: <a class="el" href="classsigc_1_1track__obj__functor7.html#a77667be610a480c7afdb928533b02651">sigc::track_obj_functor7< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6, T_obj7 ></a>
+</li>
+<li>trackable()
+: <a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">sigc::trackable</a>
+</li>
+<li>type
+: <a class="el" href="structsigc_1_1deduce__result__type.html#a529a6b7809ea3ad1a2d4392b9ffcec42">sigc::deduce_result_type< T_functor, T_args ></a>
+, <a class="el" href="structsigc_1_1unwrap__reference.html#af35cad963fc073623282a2fb9c81f02a">sigc::unwrap_reference< T_type ></a>
+, <a class="el" href="structsigc_1_1unwrap__reference_3_01const__reference__wrapper_3_01T__type_01_4_01_4.html#a9820651050b0059841f9a92d9c478ba8">sigc::unwrap_reference< const_reference_wrapper< T_type > ></a>
+, <a class="el" href="structsigc_1_1unwrap__reference_3_01reference__wrapper_3_01T__type_01_4_01_4.html#a25182a927492ff79290f9820f7131e58">sigc::unwrap_reference< reference_wrapper< T_type > ></a>
+, <a class="el" href="structsigc_1_1unwrap__reference_3_01std_1_1reference__wrapper_3_01T__type_01_4_01_4.html#a2a9edeecf0de1843fb4d218f68ae86c4">sigc::unwrap_reference< std::reference_wrapper< T_type > ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Typedefs</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_a"></a>- a -</h3><ul>
+<li>adaptor_type
+: <a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html#ad3bd68364a24b2b6580b523d5301b25c">sigc::adaptor_trait< T_functor, false ></a>
+, <a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html#a449daad4cd77bd1fbfe59d8fae9d9039">sigc::adaptor_trait< T_functor, true ></a>
+, <a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">sigc::adapts< T_functor ></a>
+, <a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ac6004db92703257f83addd412037f1f7">sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ac249b81b5d6fff6e7c4b1d9b47a98077">sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="structsigc_1_1compose1__functor.html#a90d506f177dca8afeaef61b6b5956541">sigc::compose1_functor< T_setter, T_getter ></a>
+, <a class="el" href="structsigc_1_1compose2__functor.html#ac1c9b3dc43cc75ec65fe0708fb4450d8">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a>
+, <a class="el" href="structsigc_1_1exception__catch__functor.html#a5dc4ecab205c7ad5c3954c2572d4cc08">sigc::exception_catch_functor< T_functor, T_catcher, T_return ></a>
+, <a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#aa9803c7bd355ae0674dbfabf346676c0">sigc::exception_catch_functor< T_functor, T_catcher, void ></a>
+, <a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a33b1c4635aad21aac771627a9a9fe60f">sigc::hide_functor< 0, T_functor ></a>
+, <a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a1f2c49ddcd02a3b7f240f0d0e6f0eec5">sigc::hide_functor<-1, T_functor ></a>
+, <a class="el" href="structsigc_1_1retype__functor.html#ace4a0fc864a6417a7cb36adf011177e0">sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 ></a>
+, <a class="el" href="classsigc_1_1track__obj__functor1.html#ab36332c8e8815546730b525f739d9ebf">sigc::track_obj_functor1< T_functor, T_obj1 ></a>
+</li>
+<li>arg1_type_
+: <a class="el" href="classsigc_1_1slot1.html#a4d81838957a9ccc6cb4c104706a37a89">sigc::slot1< T_return, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1slot2.html#ae69b03a4119d61a0a521b0ad5ddaae46">sigc::slot2< T_return, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1slot3.html#ac6791fffc805aa2303713fea377dbaae">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1slot4.html#a4426d0dcf517d0d815d6add3c9490437">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1slot5.html#aeda4706cbac7cb87a276ffeb8bdada16">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1slot6.html#a98240591834da17569f94410684120ba">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1slot7.html#a58edf93a837003d1a69fc77d39fc11a9">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>arg2_type_
+: <a class="el" href="classsigc_1_1slot2.html#af03b1377bbfcdc742a7c00f4c2c419f7">sigc::slot2< T_return, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1slot3.html#a7390ac1945e87a1e0d172fe266a58d72">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1slot4.html#abf1d276525f0120a734b2b054b9cfb3f">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1slot5.html#ad93d2b3cdce1c3990bde0f49693096e1">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1slot6.html#a44b34c5068d0150922cc630400a1962a">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1slot7.html#ad144d8ea3ecb891d358b5b1b969be7e2">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>arg3_type_
+: <a class="el" href="classsigc_1_1slot3.html#a54a09bfe0dd9c518ec22cc14a7e43a23">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1slot4.html#ae1af3fbe3981779b68f5676f46f6085c">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1slot5.html#aab17d4f2a38e02219c1a4757ba268baf">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1slot6.html#a05f153d441986f23d115bf29c92736ca">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1slot7.html#af90cd5954008a84d6459d99de152a08c">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>arg4_type_
+: <a class="el" href="classsigc_1_1slot4.html#aec7f4747dbe5b581c65c07033ca1bfe5">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1slot5.html#afe7fd46dc4b01397db2c2a9c70b02735">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1slot6.html#a285a8d86913eff1b27b89f4d795190c1">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1slot7.html#af42bc9af248b7c2226d93230bd7b1024">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>arg5_type_
+: <a class="el" href="classsigc_1_1slot5.html#ade67aef04bbfd7c6af63e93afc709321">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1slot6.html#a4a304a22b1a1fae56b7998ae4ae3c0e1">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1slot7.html#ad6c1006a29f6fcb721bc39e8d6f82323">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>arg6_type_
+: <a class="el" href="classsigc_1_1slot6.html#ae935d9ad4042e4cfb0730e2855d7882e">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1slot7.html#ae25a8a8663addfce52415a20725a3b3e">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>arg7_type_
+: <a class="el" href="classsigc_1_1slot7.html#a2dc6c96b8d014fab9daea823188ca021">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Typedefs</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_c"></a>- c -</h3><ul>
+<li>const_iterator
+: <a class="el" href="classsigc_1_1signal0.html#ad4f7c62954f5c270e115d9b2a2df15ea">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#af1e262b35c9574e65b2607cdfcaad707">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#ad507bc5ea29adb2305f8fa91acbd30ee">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#a60e1ef95f82cd8981d61576d1e3f8e94">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#a3d2626edc726047c04c8fe5b9824b958">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#a17e79eed46f178a12d2751eddcf85290">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#ac88a9c4e9bab5ad04c66d3f5d3978f0f">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#a6eef6225eba66a86dd32c3f3b79845f7">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+, <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">sigc::slot_list< T_slot ></a>
+</li>
+<li>const_reference
+: <a class="el" href="structsigc_1_1slot__list.html#a3ac6e61271e7e8623d1bd493c61f1214">sigc::slot_list< T_slot ></a>
+</li>
+<li>const_reverse_iterator
+: <a class="el" href="classsigc_1_1signal0.html#a476f559a69eef5999c99cd6262a9aa2f">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#aeb327519f808dfec9a723511ef82caa3">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#aacb8fe57ffe01dea5c5fb5af44634287">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#a4ba3eb58c4c5ac2c25f49c48fd0af264">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#a555ce030884fdf2bde788b75db01bedf">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#ad5ba46907fe236e0cff806888696d569">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#aff490e7f75a83aa2f324a859f9071a79">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#ad1ba32ad7dae0c05a4012ada78077505">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+, <a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">sigc::slot_list< T_slot ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Typedefs</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_d"></a>- d -</h3><ul>
+<li>difference_type
+: <a class="el" href="structsigc_1_1slot__const__iterator.html#ac111b0a48ab96f75e720f32171072bc5">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#adb6307ee06c592d67ecef0607f319d5e">sigc::slot_iterator< T_slot ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Typedefs</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_e"></a>- e -</h3><ul>
+<li>emitter_type
+: <a class="el" href="classsigc_1_1signal0.html#ac7eafdced2d325d6003327b4360bc2dd">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#a63c6e2b55c8c3af083402bb7f5a66593">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#a01379d580d21de8bc8d0d2d62e6324ea">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#adf54ec96c5fb78d4c8b7fc032a1937ad">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#acf3d1e6d6487c0ecc13ed3eab949eec7">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#a7d77e5fa748b024842bf92e28cf0f4ab">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#acdd2683223e4701f58350152f32f4488">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#a7fa856e67a31c86538db7c289a6870e3">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Typedefs</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_f"></a>- f -</h3><ul>
+<li>func_destroy_notify
+: <a class="el" href="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341">sigc::slot_base</a>
+, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">sigc::trackable</a>
+</li>
+<li>function_type
+: <a class="el" href="classsigc_1_1bound__const__mem__functor0.html#a12ae83ad7820bd716ed8a07484a339d9">sigc::bound_const_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor1.html#a65f0cde178bdd7a26fe687a8748dac4e">sigc::bound_const_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor2.html#abe2916ee9b6867554b48370000eb6886">sigc::bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor3.html#ab4e793d8c65bf8754aea133a2473dc6c">sigc::bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a3ffc5790ded15878ce2704072791c4e9">sigc::bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a882a71b51f303ded9d1ce172b522692a">sigc::bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a9cd70f288cac9b8d7ee9695166f3d306">sigc::bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor7.html#ae95db1c3ce4d07122e39dde2c9c5af02">sigc::bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html#a622322ff2ef93f0e611fd6f93f6ccdcc">sigc::bound_const_volatile_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html#ac7a0c09914219d8baf1715675e838e59">sigc::bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a26e4bc5d2c64c1029b760fe7994fee3f">sigc::bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#ae127200c20b69f91ccaf40eb60f2c448">sigc::bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#a2c06c731ae9564be215802a98541d06c">sigc::bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#a54debcbe3edf1a9606aad9cfcc1e004c">sigc::bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#aa8d75053aa097f0632c13bf1185f84a9">sigc::bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#a48030a47276e3eede338fc78c79e5a35">sigc::bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor0.html#a36b5479bfc091c063d44b11ad024393a">sigc::bound_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor1.html#a8e460c2a0eb87dcaf263c984b4dc5888">sigc::bound_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor2.html#a1b0b5d2145f50d19214ff41bd45ab978">sigc::bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor3.html#a66d1aa7ad3edafd8851ee0b334f83efe">sigc::bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor4.html#aeddcfc0ce5fe38259608bfc88af37568">sigc::bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor5.html#a91181f20bd393befce307655486949ad">sigc::bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor6.html#ac92e6b87056623eeec0d09a35f41296d">sigc::bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor7.html#a0fcd4636185a806d055d6b885503863b">sigc::bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html#a9a07aa91b2bd5ef0c4fc1a89bad5d3b0">sigc::bound_volatile_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html#a38ee12aba5c1d6a7c608165a1137219a">sigc::bound_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#a16d5240b9bbb31ae266725d20b0f37d7">sigc::bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#abc967931a7ab1411e02c022035073be5">sigc::bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#a7a30b6a2e3067254fdea50104fea8469">sigc::bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#a1561f499bd4d950fd36ee43ee60db585">sigc::bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#a6eeca5f695bff3c3302e4cf7d222a73d">sigc::bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#afce6246f9f2828a7185b3c696435d70a">sigc::bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor0.html#a5b768319ee81e2aa9e96a900e5e64996">sigc::const_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor1.html#a14e585a05b63c5e4790b3de75cb18c96">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor2.html#a2294d014482fee6845b69ab5bc27daa9">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor3.html#accd266c72527ca411756bd9a4045eac9">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor4.html#a775bb61661f2a7007b36f16ee106a8ad">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor5.html#aa58310b256b11e94d9a757acf60b410a">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor6.html#ad64803b1192e1007887f234b8c7421ac">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor7.html#a73af81d23d0fa816b8ef00acb1970d43">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#a3247f7d0e3804ff455e0996b969f6c59">sigc::const_volatile_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#acc367f8d6ee646c370623650a7ed6cde">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#ac46d1e343e669092d6bb24aa8b5d5dbb">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a472ab7835e2b6792a108f4fcc80d4669">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#ace3cb54e6265ebe06ee2995dd01f2540">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a1d49a5a7086d41d1db2e40aed1273631">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#af8da04ac5f6e2252f963f4f4bb87c9fd">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a7e3bac9b817c848b96e9d1b257be1de5">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1mem__functor0.html#a2b54ee0f1d0b0ca4f25707c85a5d4bab">sigc::mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1mem__functor1.html#a4f10314fc4d7811e126aa0d8dc9fea8c">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1mem__functor2.html#aa584cfe15bb8dc5b2931d2bfd034c118">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1mem__functor3.html#a8da99a5dcfe5ae1cecd6ce93ab91b929">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1mem__functor4.html#a9dcf1ef95187c2588ecf2abb089cc7c8">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1mem__functor5.html#a66e9bb0c9829b13af029ee2127b54eb5">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1mem__functor6.html#a202287b72f6213f64a696b185fb90268">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1mem__functor7.html#a408f0afec5b4c750ca8e1bdab0f8b535">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor0.html#a2f0448d35b580f2b4884292f29b19b2f">sigc::volatile_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor1.html#a49228c222297c3f116b132370c3f054d">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor2.html#a5faa6d84f05d64ff92e9e4ba6b8bcc1f">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor3.html#aadf62624c12ef82ade8114184f0882c9">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor4.html#a697cad0c578cd4ba3e04f6db8a39e283">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor5.html#a43ce719034586bbd097c823376c288ef">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor6.html#a67b3a13a2f595360ff6f78cb96efe9d1">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor7.html#a4ee701fd029c3b7f2f3a3af1aef428a0">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>functor_type
+: <a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html#acb1a7066d665d00e2525c49d089efc0f">sigc::adaptor_trait< T_functor, false ></a>
+, <a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html#ae065e339af2abe58cad43d630328240f">sigc::adaptor_trait< T_functor, true ></a>
+, <a class="el" href="structsigc_1_1functor__trait.html#ac779b3d3d04e78d57b6b2ae4545b1667">sigc::functor_trait< T_functor, I_derives_functor_base, I_can_use_decltype ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Typedefs</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_g"></a>- g -</h3><ul>
+<li>getter1_type
+: <a class="el" href="structsigc_1_1compose2__functor.html#ab7ab82eee45e8df9116a5a2b7c12c39c">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a>
+</li>
+<li>getter2_type
+: <a class="el" href="structsigc_1_1compose2__functor.html#a75e252684d06f75f036043df56d8df69">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a>
+</li>
+<li>getter_type
+: <a class="el" href="structsigc_1_1compose1__functor.html#ad54c2d62658fb7a47da41df0ccfc618c">sigc::compose1_functor< T_setter, T_getter ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Typedefs</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_i"></a>- i -</h3><ul>
+<li>iterator
+: <a class="el" href="classsigc_1_1signal0.html#ad61e875748cf4e1c2a6d89a930ae093e">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#ab61e2d1fcaf903dffbb26b01800907fb">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#a658ba1c6468882c9b1d480be2bbaf55e">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#a8029a48126a2018947a2b6680ddabe6b">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#a31e8354263a3097bba9c63b8494143f0">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#acee689b441305fcee098345729fc28f3">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#a1acee11287974cdac1bc63c856e5331d">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+, <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">sigc::slot_list< T_slot ></a>
+</li>
+<li>iterator_category
+: <a class="el" href="structsigc_1_1slot__const__iterator.html#afc9dff16373a2fa7a4f373bd48a852c6">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#a0c882521b418b9faaac879a1d337ace5">sigc::slot_iterator< T_slot ></a>
+</li>
+<li>iterator_type
+: <a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">sigc::signal_base</a>
+, <a class="el" href="structsigc_1_1slot__const__iterator.html#a3466a35177b6a0999a12ff0ee10e91b9">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#a189fa620b9d90dc1a224d9ad91da5011">sigc::slot_iterator< T_slot ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Typedefs</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_p"></a>- p -</h3><ul>
+<li>parent_type
+: <a class="el" href="classsigc_1_1slot.html#a1966941e9654adfb3af4b994fd18a7f3">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a9937c7fbdb8be4e387fddcebf328fa41">sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a2b6b5b8590577c765c7a32f7e619250a">sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a867e776b644ca32a703866a424ae3ba5">sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#adbafac5ab39a4a017406ac9587c9511c">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a704393344c1ba2f6bdda9b466bb81af1">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a013f4139332e23166f7db3be6da4ba91">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a9c9028da9fc75a10c6c396673159d471">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a>
+</li>
+<li>pass
+: <a class="el" href="structsigc_1_1type__trait.html#aebfa426334f8de7b93031de35d2495e3">sigc::type_trait< T_type ></a>
+, <a class="el" href="structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html#a7b9cd2a3e6e7cf986e4e25e05c665c73">sigc::type_trait< const T_type & ></a>
+, <a class="el" href="structsigc_1_1type__trait_3_01T__type_01_6_01_4.html#a1b24e79fed94df3fc0e7574e0ae1c991">sigc::type_trait< T_type & ></a>
+, <a class="el" href="structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html#abfd06dd56be6fda2436e9e15acb1fc72">sigc::type_trait< T_type[N]></a>
+, <a class="el" href="structsigc_1_1type__trait_3_01void_01_4.html#ab5d97b4ec126f3afeaf67e9a6b05b0be">sigc::type_trait< void ></a>
+</li>
+<li>pointer
+: <a class="el" href="structsigc_1_1slot__const__iterator.html#a28f3f0d2ac11dd8805d75682d8f38022">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#afb36f2add6064e0d7e7ae63ee2ddcde9">sigc::slot_iterator< T_slot ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Typedefs</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_r"></a>- r -</h3><ul>
+<li>reference
+: <a class="el" href="structsigc_1_1slot__const__iterator.html#a8300967b4b29096e7ad0b96db04e095a">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#aa3e69a557b73d817a1951af1b1767632">sigc::slot_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__list.html#ab0f2255639f24ff02d45f97994bc0e11">sigc::slot_list< T_slot ></a>
+</li>
+<li>result_type
+: <a class="el" href="structsigc_1_1adaptor__functor.html#adc1e7ebba9db294494c62666e10b719b">sigc::adaptor_functor< T_functor ></a>
+, <a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html#a512a6d201bdd43574a2df993b3b85d0e">sigc::adaptor_trait< T_functor, false ></a>
+, <a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html#a6b83ed91f53a25e7002546a2835457b3">sigc::adaptor_trait< T_functor, true ></a>
+, <a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">sigc::adapts< T_functor ></a>
+, <a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a1c6d091ffd70c23930cf6e2b9042d466">sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#abd1e51093bf7d4428e443c2e6704bed9">sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a>
+, <a class="el" href="structsigc_1_1bind__return__functor.html#a4fe6cb8d80573ae7abe934ba54879592">sigc::bind_return_functor< T_return, T_functor ></a>
+, <a class="el" href="structsigc_1_1compose1__functor.html#ab096c0a388f877d97b3812f2fcc813f9">sigc::compose1_functor< T_setter, T_getter ></a>
+, <a class="el" href="structsigc_1_1compose2__functor.html#a78ccb07f23696a452df9f61308885542">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor0.html#a553cd4d85524b5deea445b67773527bf">sigc::const_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor1.html#a8ba6a6565b8a29812e266aa4e5261a2d">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor2.html#a5eaa5f2ab10ad755c89ff5b09c1e281d">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor3.html#ae67fd219e64f81359640873d30123c9d">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor4.html#a78069750e64446199d91c0682b0915cc">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor5.html#a9d952d52dade789bc38953c4c83fb425">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor6.html#adf81aebfa633d0bf14a0d3f5e9688561">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor7.html#a724b8b210493e0d3cf06b5a393b91546">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#ab8e419ef5ad21d6230a306cd7d910df9">sigc::const_volatile_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#adeaf82cc2aff607efe2a51945d6b8565">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#a0d143bb32627f7a0c17270321df8145f">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#ad2056f73eed4664ff41f5e673a2276f0">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a8e38a0816627c7ad4fd48278d287f863">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a42d6cd140b98358c1d12c90b975ad2b1">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#a9f866db08b59a0960875f7608a0c93f0">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a25cb7e6ed71406c5b91ab2696ad8e623">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="structsigc_1_1exception__catch__functor.html#a498f5575ae283594cfe03288fab54fdf">sigc::exception_catch_functor< T_functor, T_catcher, T_return ></a>
+, <a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a06506e0d4da26682740b7f4f9aec80d5">sigc::exception_catch_functor< T_functor, T_catcher, void ></a>
+, <a class="el" href="structsigc_1_1functor__trait.html#af1324bf0d3cec3d1f2e39e932b228d6d">sigc::functor_trait< T_functor, I_derives_functor_base, I_can_use_decltype ></a>
+, <a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#af5b5ee49bb277471b5bc8e3769d0dcb7">sigc::hide_functor< 0, T_functor ></a>
+, <a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a72ea0ce5ad7cf4f9e0e7b160d830c5a4">sigc::hide_functor<-1, T_functor ></a>
+, <a class="el" href="classsigc_1_1mem__functor0.html#aa679f73c7b786540686c110628a71dde">sigc::mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1mem__functor1.html#a7c7ab28530e2f678eae87772253df709">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1mem__functor2.html#a9080e942d35d226ea6f9dda097342f07">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1mem__functor3.html#af620103fa36aa86fb539843f7f730e01">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1mem__functor4.html#a79bf0a3c25dbe6eb07829ee55ce5d664">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1mem__functor5.html#a3e0587ce338328d42f44c4e5f79be6ed">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1mem__functor6.html#af80425ff57ca2115cba771c275f49e36">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1mem__functor7.html#a967b5f6572e988ea0833818b993745f9">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1pointer__functor0.html#af44316e53e33b4184ca151b6b11c70e5">sigc::pointer_functor0< T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor1.html#a4080910d23a74b102a123838fa93e90b">sigc::pointer_functor1< T_arg1, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor2.html#a297b784eb0cea07b364c854e5dd5f864">sigc::pointer_functor2< T_arg1, T_arg2, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor3.html#a2a0ed29803c02cc62fcc6497f83f88bf">sigc::pointer_functor3< T_arg1, T_arg2, T_arg3, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor4.html#a787f8ea1c15d7bfab7643081a408401c">sigc::pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor5.html#a00dcbec8a920ea784e3210743c77855b">sigc::pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor6.html#a9fd7af745ebad4d59f67e0f60fb395e0">sigc::pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor7.html#a41613e64e2b96656b85aa9eefa35aa91">sigc::pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return ></a>
+, <a class="el" href="structsigc_1_1retype__functor.html#a1a594553d0312ca12e1009d179af0dbe">sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 ></a>
+, <a class="el" href="structsigc_1_1retype__return__functor.html#aa8421dc266ad653de395e7d01e631fdc">sigc::retype_return_functor< T_return, T_functor ></a>
+, <a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#a64bccc59fc20fdf0fd80281597d350b2">sigc::retype_return_functor< void, T_functor ></a>
+, <a class="el" href="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1slot0.html#aca0c967b605e09d5a87015d95e93d4f7">sigc::slot0< T_return ></a>
+, <a class="el" href="classsigc_1_1slot1.html#ab4991fe5d80761ddab482fda9ebe6d17">sigc::slot1< T_return, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1slot2.html#a0bb920e3d5628c3d01a4337a2a8a97fc">sigc::slot2< T_return, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1slot3.html#a69cca26f164c63de6ffa70a3806fb936">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1slot4.html#a3f6b5b11385536c1c199ca29468c638a">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1slot5.html#aac50a6486dddcac3a42022a6f2189f09">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1slot6.html#a8dae48d6160e0f917f545eb10950a9bf">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1slot7.html#a06a374d3304636cb48fed29542dc851f">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#af593e79280c004b6ef8f4722953df0c4">sigc::slot< T_return(T_arg...)></a>
+, <a class="el" href="classsigc_1_1track__obj__functor1.html#a17ad87a124cb6fafc37a2d573d47f222">sigc::track_obj_functor1< T_functor, T_obj1 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor0.html#a41fbd67d6bbde0818b880f08f6295396">sigc::volatile_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor1.html#a3bcbf6ae6e950d35e4ac7b33fa066877">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor2.html#a67719071ed0eacd994fa6fe300cfb24d">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor3.html#a229fe43026e97bbcf80215ea8e9fa828">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor4.html#a58dd95fa47c02a9ba6340682c7dbbcb0">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor5.html#ab647ea2e44db475cc2d4bae8be842127">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor6.html#a1ce192c145ec5af4c826ccb2619cf002">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor7.html#a4762374376dcb7b11c77372edab78823">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>reverse_iterator
+: <a class="el" href="classsigc_1_1signal0.html#a1d9c390974304392ed12ee81543ab997">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#ab0443049aa736d88770d0f534600b2bc">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#a6710759bdeb8e626fc09d8c448e6613f">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#acc453f0d5fc7f277494b2d6e737f6f68">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#a1395da7d3283b0166af135193a4047c8">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#ab684cb9920d0f7949f28c03d50b58275">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#a79b741b3f0def8f52fc185ad50b60673">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#a59c9c9fee7a98528839df592241351a9">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+, <a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">sigc::slot_list< T_slot ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Typedefs</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_s"></a>- s -</h3><ul>
+<li>setter_type
+: <a class="el" href="structsigc_1_1compose1__functor.html#a86a8bc8f4926f7bb91ef362fff03a25e">sigc::compose1_functor< T_setter, T_getter ></a>
+, <a class="el" href="structsigc_1_1compose2__functor.html#ac3d7308c702df7378af1635281d5f7b8">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a>
+</li>
+<li>size_type
+: <a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">sigc::signal_base</a>
+, <a class="el" href="structsigc_1_1slot__const__iterator.html#adb1eeabfa619cbd9565aa0f9429ca5ed">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#a1dd8ea0a80b5bb0f936833a1c2e363ed">sigc::slot_iterator< T_slot ></a>
+</li>
+<li>slot_list_type
+: <a class="el" href="classsigc_1_1signal0.html#add195c1c738ee8efe10294f21d258b77">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#a5fadeb350140d6aaf560b217e7e7c4b4">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#af31262f54dfb2a97540de9c4a1fc5726">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#a3bc0616e7ac933e702a889a2a84e92d4">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#a0ad0f56a43825c6d77d36dd2f06ef828">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#a4c79ab227fc3b31b990e925636f7788e">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#a0e4fea9bd1ed35f9d60bbc26c4fae007">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+</li>
+<li>slot_type
+: <a class="el" href="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287">sigc::signal0< T_return, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c">sigc::signal1< T_return, T_arg1, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a>
+, <a class="el" href="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a>
+, <a class="el" href="structsigc_1_1slot__const__iterator.html#ae377905cad9a91ca23d09877c72d82cd">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#af7a0ed93fca0064021d77275305e04a9">sigc::slot_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__list.html#af769819a62b19adb888eb231709e894f">sigc::slot_list< T_slot ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Typedefs</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_t"></a>- t -</h3><ul>
+<li>take
+: <a class="el" href="structsigc_1_1type__trait.html#a191a797ea6e2d851287b8a87b6305157">sigc::type_trait< T_type ></a>
+, <a class="el" href="structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html#a2c3a2a62adee114867045a7f77096435">sigc::type_trait< const T_type & ></a>
+, <a class="el" href="structsigc_1_1type__trait_3_01T__type_01_6_01_4.html#a604c7ad05de42e3f9d28ab45c8d865b5">sigc::type_trait< T_type & ></a>
+, <a class="el" href="structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html#a9cb9e2faaa68a89ef1a74b8b7c98d81e">sigc::type_trait< T_type[N]></a>
+, <a class="el" href="structsigc_1_1type__trait_3_01void_01_4.html#a40d187392469ee48d24838ef38531b90">sigc::type_trait< void ></a>
+</li>
+<li>type
+: <a class="el" href="structsigc_1_1deduce__result__type.html#a529a6b7809ea3ad1a2d4392b9ffcec42">sigc::deduce_result_type< T_functor, T_args ></a>
+, <a class="el" href="structsigc_1_1unwrap__reference.html#af35cad963fc073623282a2fb9c81f02a">sigc::unwrap_reference< T_type ></a>
+, <a class="el" href="structsigc_1_1unwrap__reference_3_01const__reference__wrapper_3_01T__type_01_4_01_4.html#a9820651050b0059841f9a92d9c478ba8">sigc::unwrap_reference< const_reference_wrapper< T_type > ></a>
+, <a class="el" href="structsigc_1_1unwrap__reference_3_01reference__wrapper_3_01T__type_01_4_01_4.html#a25182a927492ff79290f9820f7131e58">sigc::unwrap_reference< reference_wrapper< T_type > ></a>
+, <a class="el" href="structsigc_1_1unwrap__reference_3_01std_1_1reference__wrapper_3_01T__type_01_4_01_4.html#a2a9edeecf0de1843fb4d218f68ae86c4">sigc::unwrap_reference< std::reference_wrapper< T_type > ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Typedefs</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_v"></a>- v -</h3><ul>
+<li>value_type
+: <a class="el" href="structsigc_1_1slot__const__iterator.html#a20a9337066a01a137ea9945bdd509e80">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#a94f7fcbd3224e1f7e88b84f9e326b0b3">sigc::slot_iterator< T_slot ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all class members with links to the classes they belong to:</div>
+
+<h3><a id="index_u"></a>- u -</h3><ul>
+<li>unblock()
+: <a class="el" href="structsigc_1_1connection.html#a15abcbfa76f1e5d8601cf4ad4176ed50">sigc::connection</a>
+, <a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">sigc::signal_base</a>
+, <a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d">sigc::slot_base</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all class members with links to the classes they belong to:</div>
+
+<h3><a id="index_v"></a>- v -</h3><ul>
+<li>value
+: <a class="el" href="classsigc_1_1can__deduce__result__type__with__decltype.html#a3e390d22fe03a03bb34bb38bca1aea91">sigc::can_deduce_result_type_with_decltype< T_functor ></a>
+</li>
+<li>value_
+: <a class="el" href="structsigc_1_1const__reference__wrapper.html#aaaba3da60073e485144be648f8c4f69f">sigc::const_reference_wrapper< T_type ></a>
+, <a class="el" href="structsigc_1_1reference__wrapper.html#acf0463810eeadc10cc3dd2eab900145f">sigc::reference_wrapper< T_type ></a>
+</li>
+<li>value_type
+: <a class="el" href="structsigc_1_1slot__const__iterator.html#a20a9337066a01a137ea9945bdd509e80">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#a94f7fcbd3224e1f7e88b84f9e326b0b3">sigc::slot_iterator< T_slot ></a>
+</li>
+<li>visit()
+: <a class="el" href="classsigc_1_1bound__argument.html#ab29e53c5e983c45e4963e0ecace26465">sigc::bound_argument< T_type ></a>
+, <a class="el" href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html#a11b6cda42100c2c463e50942c41ff9eb">sigc::bound_argument< const_reference_wrapper< T_wrapped > ></a>
+, <a class="el" href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html#a5123890110dc1013071e68a615692ce3">sigc::bound_argument< reference_wrapper< T_wrapped > ></a>
+, <a class="el" href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html#a3d34b13540ac33e677024727ffd3a36e">sigc::bound_argument< std::reference_wrapper< T_wrapped > ></a>
+, <a class="el" href="classsigc_1_1const__limit__reference.html#aa7486303566b2a9a74e55561083ed3d9">sigc::const_limit_reference< T_type, I_derives_trackable ></a>
+, <a class="el" href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html#abe87b8e67b8a26658a5d6f45b036721a">sigc::const_limit_reference< T_type, true ></a>
+, <a class="el" href="classsigc_1_1const__volatile__limit__reference.html#a41c17ef86e8c65998ba42097c7ad5f09">sigc::const_volatile_limit_reference< T_type, I_derives_trackable ></a>
+, <a class="el" href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html#a332d07b8ef0005163f02df234f014814">sigc::const_volatile_limit_reference< T_type, true ></a>
+, <a class="el" href="classsigc_1_1limit__reference.html#affeb3929fdc606c8fb7f8f29fa6fd12d">sigc::limit_reference< T_type, I_derives_trackable ></a>
+, <a class="el" href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html#a85e56a8140929d71b2bdbd091e348c3a">sigc::limit_reference< T_type, true ></a>
+, <a class="el" href="classsigc_1_1volatile__limit__reference.html#a4d67fe2d9d27c326136a9e5ac13a1a75">sigc::volatile_limit_reference< T_type, I_derives_trackable ></a>
+, <a class="el" href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html#a187454d57b2c1edefb5594fcd0175835">sigc::volatile_limit_reference< T_type, true ></a>
+</li>
+<li>volatile_limit_reference()
+: <a class="el" href="classsigc_1_1volatile__limit__reference.html#acb3e6e1ecc628343f94faae718b58066">sigc::volatile_limit_reference< T_type, I_derives_trackable ></a>
+, <a class="el" href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html#aa0b69d0a82616d6db2eb86d7a041df23">sigc::volatile_limit_reference< T_type, true ></a>
+</li>
+<li>volatile_mem_functor0()
+: <a class="el" href="classsigc_1_1volatile__mem__functor0.html#ae29bbe3e668b370d2788631465daa63c">sigc::volatile_mem_functor0< T_return, T_obj ></a>
+</li>
+<li>volatile_mem_functor1()
+: <a class="el" href="classsigc_1_1volatile__mem__functor1.html#a30ec3be683a2c466b23da53c8025608b">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+</li>
+<li>volatile_mem_functor2()
+: <a class="el" href="classsigc_1_1volatile__mem__functor2.html#a273bbe27bc7b190d8457408cd328c1f9">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+</li>
+<li>volatile_mem_functor3()
+: <a class="el" href="classsigc_1_1volatile__mem__functor3.html#a2364e6ab68a8128ba9e9973c66c0ce1d">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+</li>
+<li>volatile_mem_functor4()
+: <a class="el" href="classsigc_1_1volatile__mem__functor4.html#a5ba462855081b617085e59e7566927a7">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+</li>
+<li>volatile_mem_functor5()
+: <a class="el" href="classsigc_1_1volatile__mem__functor5.html#abe1011a71cd8e78d248e072fb7d60231">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+</li>
+<li>volatile_mem_functor6()
+: <a class="el" href="classsigc_1_1volatile__mem__functor6.html#a782bbd4bff8bd939a008ceb9e0511bae">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+</li>
+<li>volatile_mem_functor7()
+: <a class="el" href="classsigc_1_1volatile__mem__functor7.html#a07834a50703bf92aad9bc167fa256d24">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members - Variables</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_b"></a>- b -</h3><ul>
+<li>blocked_
+: <a class="el" href="classsigc_1_1slot__base.html#a9dc4958860c0f8300b461a743b7f2a2b">sigc::slot_base</a>
+</li>
+<li>bound1_
+: <a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a5e92e05deb3d9e952a49a338bac42cb4">sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a>
+</li>
+<li>bound_
+: <a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#afbbf5b4d89cf98a1224da5d72554afdc">sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a>
+</li>
+</ul>
+
+
+<h3><a id="index_c"></a>- c -</h3><ul>
+<li>catcher_
+: <a class="el" href="structsigc_1_1exception__catch__functor.html#af94123d76a61a13258893ed575a019b0">sigc::exception_catch_functor< T_functor, T_catcher, T_return ></a>
+, <a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#acc50467493545db2b55e638f7ac28c42">sigc::exception_catch_functor< T_functor, T_catcher, void ></a>
+</li>
+</ul>
+
+
+<h3><a id="index_f"></a>- f -</h3><ul>
+<li>func_ptr_
+: <a class="el" href="classsigc_1_1const__mem__functor0.html#a215359b20450c2afe93496826ac45c1d">sigc::const_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor1.html#af791174008d5b58aa0f4fb42a531cc4a">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor2.html#a4445ff55323e94d525c1b2574ee32ddc">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor3.html#ad86eb326f14c401748d0a118265e558d">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor4.html#ac0feeedacde97bd166141c285fa2c74c">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor5.html#aeb6e66e0304e5c039d97264a3dd7d6e9">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor6.html#a665c77c3da00d474d6d999c394801a98">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1const__mem__functor7.html#a255588607e165db8bd25c3bb8d7e1fbe">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html#ae0f88c6683fb175845f5f804c2c04ec8">sigc::const_volatile_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html#af9da27522999030f09c718dbe164f1f6">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html#aac7f64e6cff784ecd6700d0448d8e796">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html#a6ffedac451ab4f525bd7c9df0b83cf2c">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html#a0714aabc799c5d41af988650fec71410">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html#a785d079f14f42cafd052639a1ebdaeb9">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html#aed412f2606f91f9c11567c37ae6175bc">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html#a3f19b8bff74776f040492d3410c54fa1">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1mem__functor0.html#a1f7b51d412900f55e155ecdd848fa283">sigc::mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1mem__functor1.html#af5981be86ea36d59e86234ef5cd2b5a4">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1mem__functor2.html#aa4b00e1d6bb65c1c1791d314b5dcb4d6">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1mem__functor3.html#ac7ed881bf6b6ef8c7ed418ad3bfc0ccc">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1mem__functor4.html#a28282d9285ca1a2075fd8041905a6302">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1mem__functor5.html#a73a58b713dccc6a48b0083063b0df719">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1mem__functor6.html#af07a44f7435cf15228903b0868fac956">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1mem__functor7.html#a779c41d697c3b80d08a06cbcc9a5ea25">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1pointer__functor0.html#af998b64dac7b3c7eeb2e9a2856a4213e">sigc::pointer_functor0< T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor1.html#a864ab55240be5287faf07c341ae9501e">sigc::pointer_functor1< T_arg1, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor2.html#a340680ba8ae5ea67eb0afe33d118c82b">sigc::pointer_functor2< T_arg1, T_arg2, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor3.html#a1ac1e43f2515d64c0da4656cdfac1f44">sigc::pointer_functor3< T_arg1, T_arg2, T_arg3, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor4.html#af7079533ac64ac9ba23eab99e5c54269">sigc::pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor5.html#a1c97e4e7e8598e06802b07cb86b32466">sigc::pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor6.html#a69c965009b6c3b65106c731b20e60368">sigc::pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return ></a>
+, <a class="el" href="classsigc_1_1pointer__functor7.html#aa092fb6515cb3496529b253b1a57118b">sigc::pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor0.html#a874e91ca403b95bb085ed596257de3ec">sigc::volatile_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor1.html#ad07b2821f95c27c013af4fdce527c1cb">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor2.html#aafe942fe06b2687338ea82b058412d07">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor3.html#acf6a8aebcf4de461e03e9b994a807362">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor4.html#a176ab2202482276e79e6d71ff839c31d">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor5.html#a01d38ddf6e713a47199fba85fd5a8092">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor6.html#aa64e5accf2702a06bffb6ed68fd95022">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1volatile__mem__functor7.html#ac74b72d519805a654529347e4c638e6f">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+<li>functor_
+: <a class="el" href="structsigc_1_1adaptor__functor.html#a4faff6b7a82f4f6d92e3d3b0aa8fdca8">sigc::adaptor_functor< T_functor ></a>
+, <a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">sigc::adapts< T_functor ></a>
+</li>
+</ul>
+
+
+<h3><a id="index_g"></a>- g -</h3><ul>
+<li>get1_
+: <a class="el" href="structsigc_1_1compose2__functor.html#af5404ffb509175690aa896932571e8bf">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a>
+</li>
+<li>get2_
+: <a class="el" href="structsigc_1_1compose2__functor.html#af8404295ebbcb968a798c9fdf3f3d527">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a>
+</li>
+<li>get_
+: <a class="el" href="structsigc_1_1compose1__functor.html#abc9151caeb78b1cd79ce1eb6984dc066">sigc::compose1_functor< T_setter, T_getter ></a>
+</li>
+</ul>
+
+
+<h3><a id="index_i"></a>- i -</h3><ul>
+<li>i_
+: <a class="el" href="structsigc_1_1slot__const__iterator.html#a5e8020f4f1c3da18fcac4c9babee306f">sigc::slot_const_iterator< T_slot ></a>
+, <a class="el" href="structsigc_1_1slot__iterator.html#a5e113a9e58ce7e16a11838a203b72649">sigc::slot_iterator< T_slot ></a>
+</li>
+<li>impl_
+: <a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">sigc::signal_base</a>
+</li>
+</ul>
+
+
+<h3><a id="index_l"></a>- l -</h3><ul>
+<li>list_
+: <a class="el" href="structsigc_1_1slot__list.html#a2c5b3ecf068ec93cdc34a4ae8d48313c">sigc::slot_list< T_slot ></a>
+</li>
+</ul>
+
+
+<h3><a id="index_o"></a>- o -</h3><ul>
+<li>obj_
+: <a class="el" href="classsigc_1_1bound__const__mem__functor0.html#afe36947825350dc17d7fed286f57c32a">sigc::bound_const_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor1.html#ac4141561bf43206a396d082dd0089fb2">sigc::bound_const_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor2.html#a3994b65f2ec0b45f5b502f07bf7baca1">sigc::bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor3.html#ac4b0ceb88bda73c90d84b1320e274621">sigc::bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor4.html#a78490633e22357be6e0a0fcf124121b5">sigc::bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor5.html#a71f8b7b3a9971d58209c3008d5e32d79">sigc::bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor6.html#a152f10d5c46eb9d7d582a6e4cb747baf">sigc::bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1bound__const__mem__functor7.html#a2b59ccc18d96b4b2ec0f6828a5c2a6e0">sigc::bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html#adfea0aeaf66e1531da58af3051327949">sigc::bound_const_volatile_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html#a4c6537ee7b64251b8f418047cb9fd87d">sigc::bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html#a28eef54f97c2468f3385358b75d6cb70">sigc::bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html#a65b0c3f640389160aa73a299aed8c512">sigc::bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html#a52abd6d1eb7dd0919ecb6d3a667b0e18">sigc::bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html#a72dab40d6161daa1ad1655a03e5a5aa4">sigc::bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html#abbd560d8331fbab5cd8a08afd756c8fc">sigc::bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html#aec37eae62ba95f04b55dd6c55c6161c1">sigc::bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor0.html#ae64f4c6596667228376947a38c4a8bb7">sigc::bound_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor1.html#a95ae2c4525d8218569b68bbb3effbadf">sigc::bound_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor2.html#a423780eab9a560771ec3266ea0693117">sigc::bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor3.html#ae05cea0cbd3345abc624e545422bb47a">sigc::bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor4.html#aa9a90c28652fb499438e757cdc6f3be7">sigc::bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor5.html#a477578c56471258d6eaefb45713dbae8">sigc::bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor6.html#a8aced07018e8f32dcc4339ce26a0e924">sigc::bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1bound__mem__functor7.html#a03e799b2af9cdc19c76e81d0bcb843ad">sigc::bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html#abc4357df8d4458326135e23965ba5871">sigc::bound_volatile_mem_functor0< T_return, T_obj ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html#a09b9ac461833030fae01249b50e5984c">sigc::bound_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html#a80858a8bbb89469136b8e476d0bae0e6">sigc::bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html#a01d01f9945bd93e227403cdbb8271e2a">sigc::bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html#a4bb276cfe8c35645f166cde087f5d17f">sigc::bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html#ae17c42b74b72c74f3a7e4d5faadaa761">sigc::bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html#a64c4455bc351be0f2b42dc28b03baeb9">sigc::bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a>
+, <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html#a32b6c9b9aaa1e750217fc1f9d9e4b2df">sigc::bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a>
+</li>
+</ul>
+
+
+<h3><a id="index_r"></a>- r -</h3><ul>
+<li>rep_
+: <a class="el" href="classsigc_1_1slot__base.html#aa482f7dfc73c6950abde0fd51b3125b5">sigc::slot_base</a>
+</li>
+<li>ret_value_
+: <a class="el" href="structsigc_1_1bind__return__functor.html#aa7b8287c19d98cec75a7e64a9464772e">sigc::bind_return_functor< T_return, T_functor ></a>
+</li>
+</ul>
+
+
+<h3><a id="index_v"></a>- v -</h3><ul>
+<li>value
+: <a class="el" href="classsigc_1_1can__deduce__result__type__with__decltype.html#a3e390d22fe03a03bb34bb38bca1aea91">sigc::can_deduce_result_type_with_decltype< T_functor ></a>
+</li>
+<li>value_
+: <a class="el" href="structsigc_1_1const__reference__wrapper.html#aaaba3da60073e485144be648f8c4f69f">sigc::const_reference_wrapper< T_type ></a>
+, <a class="el" href="structsigc_1_1reference__wrapper.html#acf0463810eeadc10cc3dd2eab900145f">sigc::reference_wrapper< T_type ></a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all class members with links to the classes they belong to:</div>
+
+<h3><a id="index__7E"></a>- ~ -</h3><ul>
+<li>~connection()
+: <a class="el" href="structsigc_1_1connection.html#a99678ccb2be5c20719f37e469416578a">sigc::connection</a>
+</li>
+<li>~exception_catch_functor()
+: <a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a1537e7d0175046d65522bd960149bb62">sigc::exception_catch_functor< T_functor, T_catcher, void ></a>
+</li>
+<li>~signal_base()
+: <a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">sigc::signal_base</a>
+</li>
+<li>~slot_base()
+: <a class="el" href="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57">sigc::slot_base</a>
+</li>
+<li>~trackable()
+: <a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">sigc::trackable</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Graph Legend</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">Graph Legend</div> </div>
+</div><!--header-->
+<div class="contents">
+<p>This page explains how to interpret the graphs that are generated by doxygen.</p>
+<p>Consider the following example: </p><div class="fragment"><div class="line"><span class="comment">/*! Invisible class because of truncation */</span></div>
+<div class="line"><span class="keyword">class </span>Invisible { };</div>
+<div class="line"><span class="comment"></span> </div>
+<div class="line"><span class="comment">/*! Truncated class, inheritance relation is hidden */</span></div>
+<div class="line"><span class="keyword">class </span>Truncated : <span class="keyword">public</span> Invisible { };</div>
+<div class="line"> </div>
+<div class="line"><span class="comment">/* Class not documented with doxygen comments */</span></div>
+<div class="line"><span class="keyword">class </span>Undocumented { };</div>
+<div class="line"><span class="comment"></span> </div>
+<div class="line"><span class="comment">/*! Class that is inherited using public inheritance */</span></div>
+<div class="line"><span class="keyword">class </span>PublicBase : <span class="keyword">public</span> Truncated { };</div>
+<div class="line"><span class="comment"></span> </div>
+<div class="line"><span class="comment">/*! A template class */</span></div>
+<div class="line"><span class="keyword">template</span><<span class="keyword">class</span> T> <span class="keyword">class </span>Templ { };</div>
+<div class="line"><span class="comment"></span> </div>
+<div class="line"><span class="comment">/*! Class that is inherited using protected inheritance */</span></div>
+<div class="line"><span class="keyword">class </span>ProtectedBase { };</div>
+<div class="line"><span class="comment"></span> </div>
+<div class="line"><span class="comment">/*! Class that is inherited using private inheritance */</span></div>
+<div class="line"><span class="keyword">class </span>PrivateBase { };</div>
+<div class="line"><span class="comment"></span> </div>
+<div class="line"><span class="comment">/*! Class that is used by the Inherited class */</span></div>
+<div class="line"><span class="keyword">class </span>Used { };</div>
+<div class="line"><span class="comment"></span> </div>
+<div class="line"><span class="comment">/*! Super class that inherits a number of other classes */</span></div>
+<div class="line"><span class="keyword">class </span>Inherited : <span class="keyword">public</span> PublicBase,</div>
+<div class="line"> <span class="keyword">protected</span> ProtectedBase,</div>
+<div class="line"> <span class="keyword">private</span> PrivateBase,</div>
+<div class="line"> <span class="keyword">public</span> Undocumented,</div>
+<div class="line"> <span class="keyword">public</span> Templ<int></div>
+<div class="line">{</div>
+<div class="line"> <span class="keyword">private</span>:</div>
+<div class="line"> Used *m_usedClass;</div>
+<div class="line">};</div>
+</div><!-- fragment --><p> This will result in the following graph:</p>
+<center><img src="graph_legend.png" alt="" class="inline"/></center><p>The boxes in the above graph have the following meaning: </p>
+<ul>
+<li>
+A filled gray box represents the struct or class for which the graph is generated. </li>
+<li>
+A box with a black border denotes a documented struct or class. </li>
+<li>
+A box with a gray border denotes an undocumented struct or class. </li>
+<li>
+A box with a red border denotes a documented struct or class forwhich not all inheritance/containment relations are shown. A graph is truncated if it does not fit within the specified boundaries. </li>
+</ul>
+<p>The arrows have the following meaning: </p>
+<ul>
+<li>
+A dark blue arrow is used to visualize a public inheritance relation between two classes. </li>
+<li>
+A dark green arrow is used for protected inheritance. </li>
+<li>
+A dark red arrow is used for private inheritance. </li>
+<li>
+A purple dashed arrow is used if a class is contained or used by another class. The arrow is labelled with the variable(s) through which the pointed class or struct is accessible. </li>
+<li>
+A yellow dashed arrow denotes a relation between a template instance and the template class it was instantiated from. The arrow is labelled with the template parameters of the instance. </li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+46383a01da6277587400b9000f489e0a
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Adaptors</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#groups">Modules</a> |
+<a href="#nested-classes">Classes</a> </div>
+ <div class="headertitle">
+<div class="title">Adaptors</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Adaptors are functors that alter the signature of a functor's operator()().
+<a href="#details">More...</a></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="groups"></a>
+Modules</h2></td></tr>
+<tr class="memitem:group__bind"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__bind.html">bind(), bind_return()</a></td></tr>
+<tr class="memdesc:group__bind"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">sigc::bind()</a> alters an arbitrary functor by fixing arguments to certain values. <br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:group__compose"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__compose.html">compose()</a></td></tr>
+<tr class="memdesc:group__compose"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="group__compose.html#ga34cf5da8f6323bfdc41bc7113d6ad20a" title="Creates an adaptor of type sigc::compose1_functor which combines two functors.">sigc::compose()</a> combines two or three arbitrary functors. <br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:group__exception__catch"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__exception__catch.html">exception_catch()</a></td></tr>
+<tr class="memdesc:group__exception__catch"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="namespacesigc.html#a0ae3b8a1ba26920cee4d7d9df2c39ed9">sigc::exception_catch()</a> catches an exception thrown from within the wrapped functor and directs it to a catcher functor. <br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:group__hide"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__hide.html">hide(), hide_return()</a></td></tr>
+<tr class="memdesc:group__hide"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="group__hide.html#gaf2cefea3a99acd44f68121424103172d" title="Creates an adaptor of type sigc::hide_functor which adds a dummy parameter to the passed functor.">sigc::hide()</a> alters an arbitrary functor in that it adds a parameter whose value is ignored on invocation of the returned functor. <br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:group__retype"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__retype.html">retype(), retype_return()</a></td></tr>
+<tr class="memdesc:group__retype"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="group__retype.html#ga8b98eeb2a61b5b1f84dcd1d20fe666f1" title="Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed...">sigc::retype()</a> alters a sigc::pointer_functor, a sigc::mem_functor or a <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> in that it makes C-style casts to the functor's parameter types of all parameters passed through operator()(). <br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:group__track__obj"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__track__obj.html">track_obj()</a></td></tr>
+<tr class="memdesc:group__track__obj"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="group__track__obj.html#ga8fd1ab36d123ff83dd4cd8dc58bb28e2" title="Creates an adaptor of type sigc::track_obj_functor1 which wraps a functor.">sigc::track_obj()</a> tracks trackable objects, referenced from a functor. <br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Classes</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adaptor__base.html">sigc::adaptor_base</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">A hint to the compiler. <a href="structsigc_1_1adaptor__base.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adaptor__functor.html">sigc::adaptor_functor< T_functor ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Converts an arbitrary functor into an adaptor type. <a href="structsigc_1_1adaptor__functor.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adaptor__trait.html">sigc::adaptor_trait< T_functor, I_isadaptor ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Trait that specifies what is the adaptor version of a functor type. <a href="structsigc_1_1adaptor__trait.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Base type for adaptors. <a href="structsigc_1_1adapts.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1deduce__result__type.html">sigc::deduce_result_type< T_functor, T_args ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Deduce the return type of a functor. <a href="structsigc_1_1deduce__result__type.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<p>Adaptors are functors that alter the signature of a functor's operator()(). </p>
+<p>The adaptor types libsigc++ provides are created with <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">bind()</a>, <a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a" title="Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed funct...">bind_return()</a>, <a class="el" href="group__hide.html#gaf2cefea3a99acd44f68121424103172d" title="Creates an adaptor of type sigc::hide_functor which adds a dummy parameter to the passed functor.">hide()</a>, <a class="el" href="group__hide.html#gae4e6f5491471c12440f1c5d480726b98" title="Creates an adaptor of type sigc::retype_return_functor which drops the return value of the passed fun...">hide_return()</a>, <a class="el" href="group__retype.html#ga23a8cdbc12c57fbef0866b5c51d71588" title="Creates an adaptor of type sigc::retype_return_functor which performs a C-style cast on the return va...">retype_return()</a>, <a class="el" href="group__retype.html#ga8b98eeb2a61b5b1f84dcd1d20fe666f1" title="Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed...">retype()</a>, <a class="el" href="group__compose.html#ga34cf5da8f6323bfdc41bc7113d6ad20a" title="Creates an adaptor of type sigc::compose1_functor which combines two functors.">compose()</a>, <a class="el" href="namespacesigc.html#a0ae3b8a1ba26920cee4d7d9df2c39ed9">exception_catch()</a>, <a class="el" href="group__track__obj.html#ga8fd1ab36d123ff83dd4cd8dc58bb28e2" title="Creates an adaptor of type sigc::track_obj_functor1 which wraps a functor.">track_obj()</a> and group().</p>
+<p>You can easily derive your own adaptor type from <a class="el" href="structsigc_1_1adapts.html" title="Base type for adaptors.">sigc::adapts</a>. </p>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: bind(), bind_return()</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#nested-classes">Classes</a> |
+<a href="#func-members">Functions</a> </div>
+ <div class="headertitle">
+<div class="title">bind(), bind_return()<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">sigc::bind()</a> alters an arbitrary functor by fixing arguments to certain values.
+<a href="#details">More...</a></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Classes</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__functor.html">sigc::bind_functor< I_location, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that binds an argument to the wrapped functor. <a href="structsigc_1_1bind__functor.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that binds an argument to the wrapped functor. <a href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that binds 1 argument(s) to the wrapped functor. <a href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__return__functor.html">sigc::bind_return_functor< T_return, T_functor ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that fixes the return value of the wrapped functor. <a href="structsigc_1_1bind__return__functor.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
+Functions</h2></td></tr>
+<tr class="memitem:ga2f099bc6056b32f2a58134ba8537c6f4"><td class="memTemplParams" colspan="2">template<int I_location, class T_bound1 , class T_functor > </td></tr>
+<tr class="memitem:ga2f099bc6056b32f2a58134ba8537c6f4"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a>< I_location, T_functor, T_bound1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4">sigc::bind</a> (const T_functor & _A_func, T_bound1 _A_b1)</td></tr>
+<tr class="memdesc:ga2f099bc6056b32f2a58134ba8537c6f4"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">sigc::bind_functor</a> which binds the passed argument to the passed functor. <a href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4">More...</a><br /></td></tr>
+<tr class="separator:ga2f099bc6056b32f2a58134ba8537c6f4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga211b3361bb1ae7484b2b276fd926b962"><td class="memTemplParams" colspan="2">template<class T_type1 , class T_functor > </td></tr>
+<tr class="memitem:ga211b3361bb1ae7484b2b276fd926b962"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a><-1, T_functor, T_type1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__bind.html#ga211b3361bb1ae7484b2b276fd926b962">sigc::bind</a> (const T_functor & _A_func, T_type1 _A_b1)</td></tr>
+<tr class="memdesc:ga211b3361bb1ae7484b2b276fd926b962"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">sigc::bind_functor</a> which fixes the last 1 argument(s) of the passed functor. <a href="group__bind.html#ga211b3361bb1ae7484b2b276fd926b962">More...</a><br /></td></tr>
+<tr class="separator:ga211b3361bb1ae7484b2b276fd926b962"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaf1e076f0734addb8080f1cbcac602591"><td class="memTemplParams" colspan="2">template<class T_type1 , class T_type2 , class T_functor > </td></tr>
+<tr class="memitem:gaf1e076f0734addb8080f1cbcac602591"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a><-1, T_functor, T_type1, T_type2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__bind.html#gaf1e076f0734addb8080f1cbcac602591">sigc::bind</a> (const T_functor & _A_func, T_type1 _A_b1, T_type2 _A_b2)</td></tr>
+<tr class="memdesc:gaf1e076f0734addb8080f1cbcac602591"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">sigc::bind_functor</a> which fixes the last 2 argument(s) of the passed functor. <a href="group__bind.html#gaf1e076f0734addb8080f1cbcac602591">More...</a><br /></td></tr>
+<tr class="separator:gaf1e076f0734addb8080f1cbcac602591"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga047061c9fa7d9dcde68c27cceed476a1"><td class="memTemplParams" colspan="2">template<class T_type1 , class T_type2 , class T_type3 , class T_functor > </td></tr>
+<tr class="memitem:ga047061c9fa7d9dcde68c27cceed476a1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a><-1, T_functor, T_type1, T_type2, T_type3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__bind.html#ga047061c9fa7d9dcde68c27cceed476a1">sigc::bind</a> (const T_functor & _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3)</td></tr>
+<tr class="memdesc:ga047061c9fa7d9dcde68c27cceed476a1"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">sigc::bind_functor</a> which fixes the last 3 argument(s) of the passed functor. <a href="group__bind.html#ga047061c9fa7d9dcde68c27cceed476a1">More...</a><br /></td></tr>
+<tr class="separator:ga047061c9fa7d9dcde68c27cceed476a1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga8366abceb86ee653ec2ac50cef9fd16d"><td class="memTemplParams" colspan="2">template<class T_type1 , class T_type2 , class T_type3 , class T_type4 , class T_functor > </td></tr>
+<tr class="memitem:ga8366abceb86ee653ec2ac50cef9fd16d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a><-1, T_functor, T_type1, T_type2, T_type3, T_type4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__bind.html#ga8366abceb86ee653ec2ac50cef9fd16d">sigc::bind</a> (const T_functor & _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4)</td></tr>
+<tr class="memdesc:ga8366abceb86ee653ec2ac50cef9fd16d"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">sigc::bind_functor</a> which fixes the last 4 argument(s) of the passed functor. <a href="group__bind.html#ga8366abceb86ee653ec2ac50cef9fd16d">More...</a><br /></td></tr>
+<tr class="separator:ga8366abceb86ee653ec2ac50cef9fd16d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga7f163c830d7906906cf21ff0c5e0f17f"><td class="memTemplParams" colspan="2">template<class T_type1 , class T_type2 , class T_type3 , class T_type4 , class T_type5 , class T_functor > </td></tr>
+<tr class="memitem:ga7f163c830d7906906cf21ff0c5e0f17f"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a><-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__bind.html#ga7f163c830d7906906cf21ff0c5e0f17f">sigc::bind</a> (const T_functor & _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4, T_type5 _A_b5)</td></tr>
+<tr class="memdesc:ga7f163c830d7906906cf21ff0c5e0f17f"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">sigc::bind_functor</a> which fixes the last 5 argument(s) of the passed functor. <a href="group__bind.html#ga7f163c830d7906906cf21ff0c5e0f17f">More...</a><br /></td></tr>
+<tr class="separator:ga7f163c830d7906906cf21ff0c5e0f17f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gac370f58b773f68c229c181f07e9b9e79"><td class="memTemplParams" colspan="2">template<class T_type1 , class T_type2 , class T_type3 , class T_type4 , class T_type5 , class T_type6 , class T_functor > </td></tr>
+<tr class="memitem:gac370f58b773f68c229c181f07e9b9e79"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a><-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__bind.html#gac370f58b773f68c229c181f07e9b9e79">sigc::bind</a> (const T_functor & _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4, T_type5 _A_b5, T_type6 _A_b6)</td></tr>
+<tr class="memdesc:gac370f58b773f68c229c181f07e9b9e79"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">sigc::bind_functor</a> which fixes the last 6 argument(s) of the passed functor. <a href="group__bind.html#gac370f58b773f68c229c181f07e9b9e79">More...</a><br /></td></tr>
+<tr class="separator:gac370f58b773f68c229c181f07e9b9e79"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga962b581ef0c17562bb3317783d3ffe7d"><td class="memTemplParams" colspan="2">template<class T_type1 , class T_type2 , class T_type3 , class T_type4 , class T_type5 , class T_type6 , class T_type7 , class T_functor > </td></tr>
+<tr class="memitem:ga962b581ef0c17562bb3317783d3ffe7d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a><-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__bind.html#ga962b581ef0c17562bb3317783d3ffe7d">sigc::bind</a> (const T_functor & _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4, T_type5 _A_b5, T_type6 _A_b6, T_type7 _A_b7)</td></tr>
+<tr class="memdesc:ga962b581ef0c17562bb3317783d3ffe7d"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">sigc::bind_functor</a> which fixes the last 7 argument(s) of the passed functor. <a href="group__bind.html#ga962b581ef0c17562bb3317783d3ffe7d">More...</a><br /></td></tr>
+<tr class="separator:ga962b581ef0c17562bb3317783d3ffe7d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaca1ae2466988d67d00a5f2cd16c8d90a"><td class="memTemplParams" colspan="2">template<class T_return , class T_functor > </td></tr>
+<tr class="memitem:gaca1ae2466988d67d00a5f2cd16c8d90a"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1bind__return__functor.html">bind_return_functor</a>< T_return, T_functor > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a">sigc::bind_return</a> (const T_functor & _A_functor, T_return _A_ret_value)</td></tr>
+<tr class="memdesc:gaca1ae2466988d67d00a5f2cd16c8d90a"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1bind__return__functor.html" title="Adaptor that fixes the return value of the wrapped functor.">sigc::bind_return_functor</a> which fixes the return value of the passed functor to the passed argument. <a href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a">More...</a><br /></td></tr>
+<tr class="separator:gaca1ae2466988d67d00a5f2cd16c8d90a"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<p><a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">sigc::bind()</a> alters an arbitrary functor by fixing arguments to certain values. </p>
+<p>Up to 7 arguments can be bound at a time. For single argument binding, overloads of <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">sigc::bind()</a> are provided that let you specify the zero-based position of the argument to fix with the first template parameter. (A value of <code>-1</code> fixes the last argument so <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">sigc::bind</a><-1>() gives the same result as <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">sigc::bind()</a>.) The types of the arguments can optionally be specified if not deduced.</p>
+<dl class="section user"><dt>Examples:</dt><dd><div class="fragment"><div class="line"><span class="keywordtype">void</span> foo(<span class="keywordtype">int</span>, <span class="keywordtype">int</span>, <span class="keywordtype">int</span>);</div>
+<div class="line"><span class="comment">// single argument binding ...</span></div>
+<div class="line"><a class="code" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4">sigc::bind</a>(&foo,1)(2,3); <span class="comment">//fixes the last (third) argument and calls foo(2,3,1)</span></div>
+<div class="line"><a class="code" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4">sigc::bind</a><-1>(&foo,1)(2,3); <span class="comment">//same as bind(&foo,1)(2,3) (calls foo(2,3,1))</span></div>
+<div class="line">sigc::bind<0>(&foo,1)(2,3); <span class="comment">//fixes the first argument and calls foo(1,2,3)</span></div>
+<div class="line">sigc::bind<1>(&foo,1)(2,3); <span class="comment">//fixes the second argument and calls foo(2,1,3)</span></div>
+<div class="line">sigc::bind<2>(&foo,1)(2,3); <span class="comment">//fixes the third argument and calls foo(2,3,1)</span></div>
+<div class="line"><span class="comment">// multi argument binding ...</span></div>
+<div class="line"><a class="code" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4">sigc::bind</a>(&foo,1,2)(3); <span class="comment">//fixes the last two arguments and calls foo(3,1,2)</span></div>
+<div class="line"><a class="code" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4">sigc::bind</a>(&foo,1,2,3)(); <span class="comment">//fixes all three arguments and calls foo(1,2,3)</span></div>
+<div class="ttc" id="agroup__bind_html_ga2f099bc6056b32f2a58134ba8537c6f4"><div class="ttname"><a href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4">sigc::bind</a></div><div class="ttdeci">bind_functor< I_location, T_functor, T_bound1 > bind(const T_functor &_A_func, T_bound1 _A_b1)</div><div class="ttdoc">Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.</div><div class="ttdef"><b>Definition:</b> bind.h:2114</div></div>
+</div><!-- fragment --></dd></dl>
+<p>The functor <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">sigc::bind()</a> returns can be passed into <a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2" title="Add a slot to the list of slots.">sigc::signal::connect()</a> directly.</p>
+<dl class="section user"><dt>Example:</dt><dd><div class="fragment"><div class="line"><a class="code" href="classsigc_1_1signal.html">sigc::signal<void></a> some_signal;</div>
+<div class="line"><span class="keywordtype">void</span> foo(<span class="keywordtype">int</span>);</div>
+<div class="line">some_signal.<a class="code" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">connect</a>(<a class="code" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4">sigc::bind</a>(&foo,1));</div>
+<div class="ttc" id="aclasssigc_1_1signal7_html_adc55ac9b0f935fd87a67904022e03cb2"><div class="ttname"><a href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">sigc::signal7::connect</a></div><div class="ttdeci">iterator connect(const slot_type &slot_)</div><div class="ttdoc">Add a slot to the list of slots.</div><div class="ttdef"><b>Definition:</b> signal.h:3871</div></div>
+<div class="ttc" id="aclasssigc_1_1signal_html"><div class="ttname"><a href="classsigc_1_1signal.html">sigc::signal</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::signal# templates.</div><div class="ttdef"><b>Definition:</b> signal.h:4015</div></div>
+</div><!-- fragment --></dd></dl>
+<p><a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a" title="Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed funct...">sigc::bind_return()</a> alters an arbitrary functor by fixing its return value to a certain value.</p>
+<dl class="section user"><dt>Example:</dt><dd><div class="fragment"><div class="line"><span class="keywordtype">void</span> foo();</div>
+<div class="line"><a class="codeRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#aaf93fdf0812752e0e02c501dea1b38f0">std::cout</a> << <a class="code" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a">sigc::bind_return</a>(&foo, 5)(); <span class="comment">// calls foo() and returns 5</span></div>
+<div class="ttc" id="aa01635_html_aaf93fdf0812752e0e02c501dea1b38f0"><div class="ttname"><a href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#aaf93fdf0812752e0e02c501dea1b38f0">std::cout</a></div><div class="ttdeci">ostream cout</div></div>
+<div class="ttc" id="agroup__bind_html_gaca1ae2466988d67d00a5f2cd16c8d90a"><div class="ttname"><a href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a">sigc::bind_return</a></div><div class="ttdeci">bind_return_functor< T_return, T_functor > bind_return(const T_functor &_A_functor, T_return _A_ret_value)</div><div class="ttdoc">Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed funct...</div><div class="ttdef"><b>Definition:</b> bind_return.h:229</div></div>
+</div><!-- fragment --></dd></dl>
+<p>You can bind references to functors by passing the objects through the std::ref() or std::cref() functions.</p>
+<dl class="section user"><dt>Example:</dt><dd><div class="fragment"><div class="line"><span class="keywordtype">int</span> some_int;</div>
+<div class="line"><a class="code" href="classsigc_1_1signal.html">sigc::signal<void></a> some_signal;</div>
+<div class="line"><span class="keywordtype">void</span> foo(<span class="keywordtype">int</span>&);</div>
+<div class="line">some_signal.<a class="code" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">connect</a>(<a class="code" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4">sigc::bind</a>(&foo, std::ref(some_int)));</div>
+</div><!-- fragment --></dd></dl>
+<p>If you bind an object of a <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> derived type to a functor by reference, a slot assigned to the bind adaptor is cleared automatically when the object goes out of scope.</p>
+<dl class="section user"><dt>Example:</dt><dd><div class="fragment"><div class="line"><span class="keyword">struct </span>bar : <span class="keyword">public</span> <a class="code" href="structsigc_1_1trackable.html">sigc::trackable</a> {} some_bar;</div>
+<div class="line"><a class="code" href="classsigc_1_1signal.html">sigc::signal<void></a> some_signal;</div>
+<div class="line"><span class="keywordtype">void</span> foo(bar&);</div>
+<div class="line">some_signal.<a class="code" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">connect</a>(<a class="code" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4">sigc::bind</a>(&foo, std::ref(some_bar)));</div>
+<div class="line"> <span class="comment">// disconnected automatically if some_bar goes out of scope</span></div>
+<div class="ttc" id="astructsigc_1_1trackable_html"><div class="ttname"><a href="structsigc_1_1trackable.html">sigc::trackable</a></div><div class="ttdoc">Base class for objects with auto-disconnection.</div><div class="ttdef"><b>Definition:</b> trackable.h:110</div></div>
+</div><!-- fragment --> </dd></dl>
+<h2 class="groupheader">Function Documentation</h2>
+<a id="ga2f099bc6056b32f2a58134ba8537c6f4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga2f099bc6056b32f2a58134ba8537c6f4">◆ </a></span>bind() <span class="overload">[1/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <int I_location, class T_bound1 , class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a><I_location, T_functor, T_bound1> sigc::bind </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_bound1 </td>
+ <td class="paramname"><em>_A_b1</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">sigc::bind_functor</a> which binds the passed argument to the passed functor. </p>
+<p>The optional template argument <em>I_location</em> specifies the zero-based position of the argument to be fixed (<code>-1</code> stands for the last argument).</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Functor that should be wrapped. </td></tr>
+ <tr><td class="paramname">_A_b1</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_func</em> with the bound argument on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga211b3361bb1ae7484b2b276fd926b962"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga211b3361bb1ae7484b2b276fd926b962">◆ </a></span>bind() <span class="overload">[2/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type1 , class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a><-1, T_functor, T_type1> sigc::bind </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_type1 </td>
+ <td class="paramname"><em>_A_b1</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">sigc::bind_functor</a> which fixes the last 1 argument(s) of the passed functor. </p>
+<p>This function overload fixes the last 1 argument(s) of <em>_A_func</em>.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Functor that should be wrapped. </td></tr>
+ <tr><td class="paramname">_A_b1</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes _A_func with the bound argument on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaf1e076f0734addb8080f1cbcac602591"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaf1e076f0734addb8080f1cbcac602591">◆ </a></span>bind() <span class="overload">[3/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type1 , class T_type2 , class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a><-1, T_functor, T_type1, T_type2> sigc::bind </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_type1 </td>
+ <td class="paramname"><em>_A_b1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_type2 </td>
+ <td class="paramname"><em>_A_b2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">sigc::bind_functor</a> which fixes the last 2 argument(s) of the passed functor. </p>
+<p>This function overload fixes the last 2 argument(s) of <em>_A_func</em>.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Functor that should be wrapped. </td></tr>
+ <tr><td class="paramname">_A_b1</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ <tr><td class="paramname">_A_b2</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes _A_func with the bound argument on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga047061c9fa7d9dcde68c27cceed476a1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga047061c9fa7d9dcde68c27cceed476a1">◆ </a></span>bind() <span class="overload">[4/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type1 , class T_type2 , class T_type3 , class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a><-1, T_functor, T_type1, T_type2, T_type3> sigc::bind </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_type1 </td>
+ <td class="paramname"><em>_A_b1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_type2 </td>
+ <td class="paramname"><em>_A_b2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_type3 </td>
+ <td class="paramname"><em>_A_b3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">sigc::bind_functor</a> which fixes the last 3 argument(s) of the passed functor. </p>
+<p>This function overload fixes the last 3 argument(s) of <em>_A_func</em>.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Functor that should be wrapped. </td></tr>
+ <tr><td class="paramname">_A_b1</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ <tr><td class="paramname">_A_b2</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ <tr><td class="paramname">_A_b3</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes _A_func with the bound argument on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga8366abceb86ee653ec2ac50cef9fd16d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga8366abceb86ee653ec2ac50cef9fd16d">◆ </a></span>bind() <span class="overload">[5/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type1 , class T_type2 , class T_type3 , class T_type4 , class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a><-1, T_functor, T_type1, T_type2, T_type3, T_type4> sigc::bind </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_type1 </td>
+ <td class="paramname"><em>_A_b1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_type2 </td>
+ <td class="paramname"><em>_A_b2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_type3 </td>
+ <td class="paramname"><em>_A_b3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_type4 </td>
+ <td class="paramname"><em>_A_b4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">sigc::bind_functor</a> which fixes the last 4 argument(s) of the passed functor. </p>
+<p>This function overload fixes the last 4 argument(s) of <em>_A_func</em>.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Functor that should be wrapped. </td></tr>
+ <tr><td class="paramname">_A_b1</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ <tr><td class="paramname">_A_b2</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ <tr><td class="paramname">_A_b3</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ <tr><td class="paramname">_A_b4</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes _A_func with the bound argument on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga7f163c830d7906906cf21ff0c5e0f17f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga7f163c830d7906906cf21ff0c5e0f17f">◆ </a></span>bind() <span class="overload">[6/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type1 , class T_type2 , class T_type3 , class T_type4 , class T_type5 , class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a><-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5> sigc::bind </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_type1 </td>
+ <td class="paramname"><em>_A_b1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_type2 </td>
+ <td class="paramname"><em>_A_b2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_type3 </td>
+ <td class="paramname"><em>_A_b3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_type4 </td>
+ <td class="paramname"><em>_A_b4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_type5 </td>
+ <td class="paramname"><em>_A_b5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">sigc::bind_functor</a> which fixes the last 5 argument(s) of the passed functor. </p>
+<p>This function overload fixes the last 5 argument(s) of <em>_A_func</em>.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Functor that should be wrapped. </td></tr>
+ <tr><td class="paramname">_A_b1</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ <tr><td class="paramname">_A_b2</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ <tr><td class="paramname">_A_b3</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ <tr><td class="paramname">_A_b4</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ <tr><td class="paramname">_A_b5</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes _A_func with the bound argument on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gac370f58b773f68c229c181f07e9b9e79"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gac370f58b773f68c229c181f07e9b9e79">◆ </a></span>bind() <span class="overload">[7/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type1 , class T_type2 , class T_type3 , class T_type4 , class T_type5 , class T_type6 , class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a><-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6> sigc::bind </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_type1 </td>
+ <td class="paramname"><em>_A_b1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_type2 </td>
+ <td class="paramname"><em>_A_b2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_type3 </td>
+ <td class="paramname"><em>_A_b3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_type4 </td>
+ <td class="paramname"><em>_A_b4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_type5 </td>
+ <td class="paramname"><em>_A_b5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_type6 </td>
+ <td class="paramname"><em>_A_b6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">sigc::bind_functor</a> which fixes the last 6 argument(s) of the passed functor. </p>
+<p>This function overload fixes the last 6 argument(s) of <em>_A_func</em>.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Functor that should be wrapped. </td></tr>
+ <tr><td class="paramname">_A_b1</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ <tr><td class="paramname">_A_b2</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ <tr><td class="paramname">_A_b3</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ <tr><td class="paramname">_A_b4</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ <tr><td class="paramname">_A_b5</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ <tr><td class="paramname">_A_b6</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes _A_func with the bound argument on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga962b581ef0c17562bb3317783d3ffe7d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga962b581ef0c17562bb3317783d3ffe7d">◆ </a></span>bind() <span class="overload">[8/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type1 , class T_type2 , class T_type3 , class T_type4 , class T_type5 , class T_type6 , class T_type7 , class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a><-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7> sigc::bind </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_type1 </td>
+ <td class="paramname"><em>_A_b1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_type2 </td>
+ <td class="paramname"><em>_A_b2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_type3 </td>
+ <td class="paramname"><em>_A_b3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_type4 </td>
+ <td class="paramname"><em>_A_b4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_type5 </td>
+ <td class="paramname"><em>_A_b5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_type6 </td>
+ <td class="paramname"><em>_A_b6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_type7 </td>
+ <td class="paramname"><em>_A_b7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">sigc::bind_functor</a> which fixes the last 7 argument(s) of the passed functor. </p>
+<p>This function overload fixes the last 7 argument(s) of <em>_A_func</em>.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Functor that should be wrapped. </td></tr>
+ <tr><td class="paramname">_A_b1</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ <tr><td class="paramname">_A_b2</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ <tr><td class="paramname">_A_b3</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ <tr><td class="paramname">_A_b4</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ <tr><td class="paramname">_A_b5</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ <tr><td class="paramname">_A_b6</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ <tr><td class="paramname">_A_b7</td><td>Argument to bind to <em>_A_func</em>. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes _A_func with the bound argument on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaca1ae2466988d67d00a5f2cd16c8d90a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaca1ae2466988d67d00a5f2cd16c8d90a">◆ </a></span>bind_return()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1bind__return__functor.html">bind_return_functor</a><T_return, T_functor> sigc::bind_return </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_functor</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return </td>
+ <td class="paramname"><em>_A_ret_value</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1bind__return__functor.html" title="Adaptor that fixes the return value of the wrapped functor.">sigc::bind_return_functor</a> which fixes the return value of the passed functor to the passed argument. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ <tr><td class="paramname">_A_ret_value</td><td>Argument to fix the return value of <em>_A_functor</em> to. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> on invokation and returns <em>_A_ret_value</em>. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: compose()</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#nested-classes">Classes</a> |
+<a href="#func-members">Functions</a> </div>
+ <div class="headertitle">
+<div class="title">compose()<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="group__compose.html#ga34cf5da8f6323bfdc41bc7113d6ad20a" title="Creates an adaptor of type sigc::compose1_functor which combines two functors.">sigc::compose()</a> combines two or three arbitrary functors.
+<a href="#details">More...</a></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Classes</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor< T_setter, T_getter ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that combines two functors. <a href="structsigc_1_1compose1__functor.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that combines three functors. <a href="structsigc_1_1compose2__functor.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
+Functions</h2></td></tr>
+<tr class="memitem:ga34cf5da8f6323bfdc41bc7113d6ad20a"><td class="memTemplParams" colspan="2">template<class T_setter , class T_getter > </td></tr>
+<tr class="memitem:ga34cf5da8f6323bfdc41bc7113d6ad20a"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1compose1__functor.html">compose1_functor</a>< T_setter, T_getter > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__compose.html#ga34cf5da8f6323bfdc41bc7113d6ad20a">sigc::compose</a> (const T_setter & _A_setter, const T_getter & _A_getter)</td></tr>
+<tr class="memdesc:ga34cf5da8f6323bfdc41bc7113d6ad20a"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1compose1__functor.html" title="Adaptor that combines two functors.">sigc::compose1_functor</a> which combines two functors. <a href="group__compose.html#ga34cf5da8f6323bfdc41bc7113d6ad20a">More...</a><br /></td></tr>
+<tr class="separator:ga34cf5da8f6323bfdc41bc7113d6ad20a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga4abf2a45eb2307a3dc5d870c86b0450d"><td class="memTemplParams" colspan="2">template<class T_setter , class T_getter1 , class T_getter2 > </td></tr>
+<tr class="memitem:ga4abf2a45eb2307a3dc5d870c86b0450d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1compose2__functor.html">compose2_functor</a>< T_setter, T_getter1, T_getter2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__compose.html#ga4abf2a45eb2307a3dc5d870c86b0450d">sigc::compose</a> (const T_setter & _A_setter, const T_getter1 & _A_getter1, const T_getter2 & _A_getter2)</td></tr>
+<tr class="memdesc:ga4abf2a45eb2307a3dc5d870c86b0450d"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1compose2__functor.html" title="Adaptor that combines three functors.">sigc::compose2_functor</a> which combines three functors. <a href="group__compose.html#ga4abf2a45eb2307a3dc5d870c86b0450d">More...</a><br /></td></tr>
+<tr class="separator:ga4abf2a45eb2307a3dc5d870c86b0450d"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<p><a class="el" href="group__compose.html#ga34cf5da8f6323bfdc41bc7113d6ad20a" title="Creates an adaptor of type sigc::compose1_functor which combines two functors.">sigc::compose()</a> combines two or three arbitrary functors. </p>
+<p>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.</p>
+<dl class="section user"><dt>Examples:</dt><dd><div class="fragment"><div class="line"><span class="keywordtype">float</span> square_root(<span class="keywordtype">float</span> a) { <span class="keywordflow">return</span> sqrtf(a); }</div>
+<div class="line"><span class="keywordtype">float</span> <a class="codeRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01568.html#gabf296b8981ebb3c123b3ba99e753598f">sum</a>(<span class="keywordtype">float</span> a, <span class="keywordtype">float</span> b) { <span class="keywordflow">return</span> a+b; }</div>
+<div class="line"><a class="codeRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#aaf93fdf0812752e0e02c501dea1b38f0">std::cout</a> << <a class="code" href="group__compose.html#ga34cf5da8f6323bfdc41bc7113d6ad20a">sigc::compose</a>(&square_root, &<a class="codeRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01568.html#gabf296b8981ebb3c123b3ba99e753598f">sum</a>)(9, 16); <span class="comment">// calls square_root(sum(3,6))</span></div>
+<div class="line"><a class="codeRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#aaf93fdf0812752e0e02c501dea1b38f0">std::cout</a> << <a class="code" href="group__compose.html#ga34cf5da8f6323bfdc41bc7113d6ad20a">sigc::compose</a>(&<a class="codeRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01568.html#gabf296b8981ebb3c123b3ba99e753598f">sum</a>, &square_root, &square_root)(9); <span class="comment">// calls sum(square_root(9), square_root(9))</span></div>
+<div class="ttc" id="aa01568_html_gabf296b8981ebb3c123b3ba99e753598f"><div class="ttname"><a href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01568.html#gabf296b8981ebb3c123b3ba99e753598f">sum</a></div><div class="ttdeci">_Tp sum() const</div></div>
+<div class="ttc" id="aa01635_html_aaf93fdf0812752e0e02c501dea1b38f0"><div class="ttname"><a href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#aaf93fdf0812752e0e02c501dea1b38f0">std::cout</a></div><div class="ttdeci">ostream cout</div></div>
+<div class="ttc" id="agroup__compose_html_ga34cf5da8f6323bfdc41bc7113d6ad20a"><div class="ttname"><a href="group__compose.html#ga34cf5da8f6323bfdc41bc7113d6ad20a">sigc::compose</a></div><div class="ttdeci">compose1_functor< T_setter, T_getter > compose(const T_setter &_A_setter, const T_getter &_A_getter)</div><div class="ttdoc">Creates an adaptor of type sigc::compose1_functor which combines two functors.</div><div class="ttdef"><b>Definition:</b> compose.h:288</div></div>
+</div><!-- fragment --></dd></dl>
+<p>The functor <a class="el" href="group__compose.html#ga34cf5da8f6323bfdc41bc7113d6ad20a" title="Creates an adaptor of type sigc::compose1_functor which combines two functors.">sigc::compose()</a> returns can be passed directly into <a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2" title="Add a slot to the list of slots.">sigc::signal::connect()</a>.</p>
+<dl class="section user"><dt>Example:</dt><dd><div class="fragment"><div class="line"><a class="code" href="classsigc_1_1signal.html">sigc::signal<float,float,float></a> some_signal;</div>
+<div class="line">some_signal.<a class="code" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">connect</a>(<a class="code" href="group__compose.html#ga34cf5da8f6323bfdc41bc7113d6ad20a">sigc::compose</a>(&square_root, &<a class="codeRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01568.html#gabf296b8981ebb3c123b3ba99e753598f">sum</a>));</div>
+<div class="ttc" id="aclasssigc_1_1signal7_html_adc55ac9b0f935fd87a67904022e03cb2"><div class="ttname"><a href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">sigc::signal7::connect</a></div><div class="ttdeci">iterator connect(const slot_type &slot_)</div><div class="ttdoc">Add a slot to the list of slots.</div><div class="ttdef"><b>Definition:</b> signal.h:3871</div></div>
+<div class="ttc" id="aclasssigc_1_1signal_html"><div class="ttname"><a href="classsigc_1_1signal.html">sigc::signal</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::signal# templates.</div><div class="ttdef"><b>Definition:</b> signal.h:4015</div></div>
+</div><!-- fragment --> </dd></dl>
+<h2 class="groupheader">Function Documentation</h2>
+<a id="ga34cf5da8f6323bfdc41bc7113d6ad20a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga34cf5da8f6323bfdc41bc7113d6ad20a">◆ </a></span>compose() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1compose1__functor.html">compose1_functor</a><T_setter, T_getter> sigc::compose </td>
+ <td>(</td>
+ <td class="paramtype">const T_setter & </td>
+ <td class="paramname"><em>_A_setter</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_getter & </td>
+ <td class="paramname"><em>_A_getter</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1compose1__functor.html" title="Adaptor that combines two functors.">sigc::compose1_functor</a> which combines two functors. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_setter</td><td>Functor that receives the return value of the invokation of <em>_A_getter</em>. </td></tr>
+ <tr><td class="paramname">_A_getter</td><td>Functor to invoke from operator()(). </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_setter</em> with the value returned from invokation of <em>_A_getter</em>. </dd></dl>
+
+</div>
+</div>
+<a id="ga4abf2a45eb2307a3dc5d870c86b0450d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga4abf2a45eb2307a3dc5d870c86b0450d">◆ </a></span>compose() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter1 , class T_getter2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1compose2__functor.html">compose2_functor</a><T_setter, T_getter1, T_getter2> sigc::compose </td>
+ <td>(</td>
+ <td class="paramtype">const T_setter & </td>
+ <td class="paramname"><em>_A_setter</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_getter1 & </td>
+ <td class="paramname"><em>_A_getter1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_getter2 & </td>
+ <td class="paramname"><em>_A_getter2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1compose2__functor.html" title="Adaptor that combines three functors.">sigc::compose2_functor</a> which combines three functors. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_setter</td><td>Functor that receives the return values of the invokation of <em>_A_getter1</em> and <em>_A_getter2</em>. </td></tr>
+ <tr><td class="paramname">_A_getter1</td><td>Functor to invoke from operator()(). </td></tr>
+ <tr><td class="paramname">_A_getter2</td><td>Functor to invoke from operator()(). </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_setter</em> with the values return from invokation of <em>_A_getter1</em> and <em>_A_getter2</em>. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: exception_catch()</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">exception_catch()<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="namespacesigc.html#a0ae3b8a1ba26920cee4d7d9df2c39ed9">sigc::exception_catch()</a> catches an exception thrown from within the wrapped functor and directs it to a catcher functor.
+</p>
+<p><a class="el" href="namespacesigc.html#a0ae3b8a1ba26920cee4d7d9df2c39ed9">sigc::exception_catch()</a> catches an exception thrown from within the wrapped functor and directs it to a catcher functor. </p>
+<p>This catcher can then rethrow the exception and catch it with the proper type.</p>
+<p>Note that the catcher is expected to return the same type as the wrapped functor so that normal flow can continue.</p>
+<p>Catchers can be cascaded to catch multiple types, because uncaught rethrown exceptions proceed to the next catcher adaptor.</p>
+<dl class="section user"><dt>Examples:</dt><dd><div class="fragment"><div class="line"><span class="keyword">struct </span>my_catch</div>
+<div class="line">{</div>
+<div class="line"> <span class="keywordtype">int</span> operator()()</div>
+<div class="line"> {</div>
+<div class="line"> <span class="keywordflow">try</span> { <span class="keywordflow">throw</span>; }</div>
+<div class="line"> <span class="keywordflow">catch</span> (<a class="codeRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a02969.html">std::range_error</a> e) <span class="comment">// catch what types we know</span></div>
+<div class="line"> { <a class="codeRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a7431d56d1e8cd7a9b854171294bd71c7">std::cerr</a> << <span class="stringliteral">"caught "</span> << e.<a class="codeRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a02965.html#a45f5b9c4b7141ac429bf6ea99a7ff6bf">what</a>() << <a class="codeRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a8b3758bb8f17c440c7963363f42f69f3">std::endl</a>; }</div>
+<div class="line"> <span class="keywordflow">return</span> 1;</div>
+<div class="line"> }</div>
+<div class="line">}</div>
+<div class="line"><span class="keywordtype">int</span> foo(); <span class="comment">// throws std::range_error</span></div>
+<div class="line"><a class="code" href="namespacesigc.html#a0ae3b8a1ba26920cee4d7d9df2c39ed9">sigc::exception_catch</a>(&foo, my_catch())();</div>
+<div class="ttc" id="aa01635_html_a7431d56d1e8cd7a9b854171294bd71c7"><div class="ttname"><a href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a7431d56d1e8cd7a9b854171294bd71c7">std::cerr</a></div><div class="ttdeci">ostream cerr</div></div>
+<div class="ttc" id="aa01635_html_a8b3758bb8f17c440c7963363f42f69f3"><div class="ttname"><a href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a8b3758bb8f17c440c7963363f42f69f3">std::endl</a></div><div class="ttdeci">basic_ostream< _CharT, _Traits > & endl(basic_ostream< _CharT, _Traits > &__os)</div></div>
+<div class="ttc" id="aa02965_html_a45f5b9c4b7141ac429bf6ea99a7ff6bf"><div class="ttname"><a href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a02965.html#a45f5b9c4b7141ac429bf6ea99a7ff6bf">std::range_error::what</a></div><div class="ttdeci">virtual const char * what() const noexcept</div></div>
+<div class="ttc" id="aa02969_html"><div class="ttname"><a href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a02969.html">std::range_error</a></div></div>
+<div class="ttc" id="anamespacesigc_html_a0ae3b8a1ba26920cee4d7d9df2c39ed9"><div class="ttname"><a href="namespacesigc.html#a0ae3b8a1ba26920cee4d7d9df2c39ed9">sigc::exception_catch</a></div><div class="ttdeci">exception_catch_functor< T_functor, T_catcher > exception_catch(const T_functor &_A_func, const T_catcher &_A_catcher)</div><div class="ttdef"><b>Definition:</b> exception_catch.h:326</div></div>
+</div><!-- fragment --></dd></dl>
+<p>The functor <a class="el" href="namespacesigc.html#a0ae3b8a1ba26920cee4d7d9df2c39ed9">sigc::exception_catch()</a> returns can be directly passed into <a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2" title="Add a slot to the list of slots.">sigc::signal::connect()</a>.</p>
+<dl class="section user"><dt>Example:</dt><dd><div class="fragment"><div class="line"><a class="code" href="classsigc_1_1signal.html">sigc::signal<int></a> some_signal;</div>
+<div class="line">some_signal.<a class="code" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">connect</a>(<a class="code" href="namespacesigc.html#a0ae3b8a1ba26920cee4d7d9df2c39ed9">sigc::exception_catch</a>(&foo, my_catch));</div>
+<div class="ttc" id="aclasssigc_1_1signal7_html_adc55ac9b0f935fd87a67904022e03cb2"><div class="ttname"><a href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">sigc::signal7::connect</a></div><div class="ttdeci">iterator connect(const slot_type &slot_)</div><div class="ttdoc">Add a slot to the list of slots.</div><div class="ttdef"><b>Definition:</b> signal.h:3871</div></div>
+<div class="ttc" id="aclasssigc_1_1signal_html"><div class="ttname"><a href="classsigc_1_1signal.html">sigc::signal</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::signal# templates.</div><div class="ttdef"><b>Definition:</b> signal.h:4015</div></div>
+</div><!-- fragment --> </dd></dl>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: hide(), hide_return()</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#nested-classes">Classes</a> |
+<a href="#func-members">Functions</a> </div>
+ <div class="headertitle">
+<div class="title">hide(), hide_return()<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="group__hide.html#gaf2cefea3a99acd44f68121424103172d" title="Creates an adaptor of type sigc::hide_functor which adds a dummy parameter to the passed functor.">sigc::hide()</a> alters an arbitrary functor in that it adds a parameter whose value is ignored on invocation of the returned functor.
+<a href="#details">More...</a></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Classes</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1hide__functor.html">sigc::hide_functor< I_location, T_functor ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that adds a dummy parameter to the wrapped functor. <a href="structsigc_1_1hide__functor.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html">sigc::hide_functor< 0, T_functor ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that adds a dummy parameter to the wrapped functor. <a href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html">sigc::hide_functor<-1, T_functor ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that adds a dummy parameter to the wrapped functor. <a href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
+Functions</h2></td></tr>
+<tr class="memitem:gaf2cefea3a99acd44f68121424103172d"><td class="memTemplParams" colspan="2">template<int I_location, class T_functor > </td></tr>
+<tr class="memitem:gaf2cefea3a99acd44f68121424103172d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1hide__functor.html">hide_functor</a>< I_location, T_functor > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__hide.html#gaf2cefea3a99acd44f68121424103172d">sigc::hide</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:gaf2cefea3a99acd44f68121424103172d"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1hide__functor.html" title="Adaptor that adds a dummy parameter to the wrapped functor.">sigc::hide_functor</a> which adds a dummy parameter to the passed functor. <a href="group__hide.html#gaf2cefea3a99acd44f68121424103172d">More...</a><br /></td></tr>
+<tr class="separator:gaf2cefea3a99acd44f68121424103172d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gacbbacd3553268d85b95e3a85aefb67e5"><td class="memTemplParams" colspan="2">template<class T_functor > </td></tr>
+<tr class="memitem:gacbbacd3553268d85b95e3a85aefb67e5"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1hide__functor.html">hide_functor</a><-1, T_functor > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__hide.html#gacbbacd3553268d85b95e3a85aefb67e5">sigc::hide</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:gacbbacd3553268d85b95e3a85aefb67e5"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1hide__functor.html" title="Adaptor that adds a dummy parameter to the wrapped functor.">sigc::hide_functor</a> which adds a dummy parameter to the passed functor. <a href="group__hide.html#gacbbacd3553268d85b95e3a85aefb67e5">More...</a><br /></td></tr>
+<tr class="separator:gacbbacd3553268d85b95e3a85aefb67e5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gae4e6f5491471c12440f1c5d480726b98"><td class="memTemplParams" colspan="2">template<class T_functor > </td></tr>
+<tr class="memitem:gae4e6f5491471c12440f1c5d480726b98"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__return__functor.html">retype_return_functor</a>< void, T_functor > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__hide.html#gae4e6f5491471c12440f1c5d480726b98">sigc::hide_return</a> (const T_functor & _A_functor)</td></tr>
+<tr class="memdesc:gae4e6f5491471c12440f1c5d480726b98"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__return__functor.html" title="Adaptor that performs a C-style cast on the return value of a functor.">sigc::retype_return_functor</a> which drops the return value of the passed functor. <a href="group__hide.html#gae4e6f5491471c12440f1c5d480726b98">More...</a><br /></td></tr>
+<tr class="separator:gae4e6f5491471c12440f1c5d480726b98"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<p><a class="el" href="group__hide.html#gaf2cefea3a99acd44f68121424103172d" title="Creates an adaptor of type sigc::hide_functor which adds a dummy parameter to the passed functor.">sigc::hide()</a> alters an arbitrary functor in that it adds a parameter whose value is ignored on invocation of the returned functor. </p>
+<p>Thus you can discard one argument of a signal.</p>
+<p>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 <code>-1</code> adds a parameter at the end so <a class="el" href="group__hide.html#gaf2cefea3a99acd44f68121424103172d" title="Creates an adaptor of type sigc::hide_functor which adds a dummy parameter to the passed functor.">sigc::hide</a><-1>() gives the same result as <a class="el" href="group__hide.html#gaf2cefea3a99acd44f68121424103172d" title="Creates an adaptor of type sigc::hide_functor which adds a dummy parameter to the passed functor.">sigc::hide()</a>.)</p>
+<p>The type of the parameter can optionally be specified if not deduced.</p>
+<dl class="section user"><dt>Examples:</dt><dd><div class="fragment"><div class="line"><span class="keywordtype">void</span> foo(<span class="keywordtype">int</span>, <span class="keywordtype">int</span>);</div>
+<div class="line"><span class="comment">// single argument hiding ...</span></div>
+<div class="line"><a class="code" href="group__hide.html#gaf2cefea3a99acd44f68121424103172d">sigc::hide</a>(&foo)(1,2,3); <span class="comment">// adds a dummy parameter at the back and calls foo(1,2)</span></div>
+<div class="line"><a class="code" href="group__hide.html#gaf2cefea3a99acd44f68121424103172d">sigc::hide</a><-1>(&foo)(1,2,3); <span class="comment">// same as sigc::hide(&foo)(1,2,3) (calls foo(1,2))</span></div>
+<div class="line">sigc::hide<0>(&foo)(1,2,3); <span class="comment">// adds a dummy parameter at the beginning and calls foo(2,3)</span></div>
+<div class="line">sigc::hide<1>(&foo)(1,2,3); <span class="comment">// adds a dummy parameter in the middle and calls foo(1,3)</span></div>
+<div class="line">sigc::hide<2>(&foo)(1,2,3); <span class="comment">// adds a dummy parameter at the back and calls foo(1,2)</span></div>
+<div class="ttc" id="agroup__hide_html_gaf2cefea3a99acd44f68121424103172d"><div class="ttname"><a href="group__hide.html#gaf2cefea3a99acd44f68121424103172d">sigc::hide</a></div><div class="ttdeci">hide_functor< I_location, T_functor > hide(const T_functor &_A_func)</div><div class="ttdoc">Creates an adaptor of type sigc::hide_functor which adds a dummy parameter to the passed functor.</div><div class="ttdef"><b>Definition:</b> hide.h:1061</div></div>
+</div><!-- fragment --></dd></dl>
+<p>The functor <a class="el" href="group__hide.html#gaf2cefea3a99acd44f68121424103172d" title="Creates an adaptor of type sigc::hide_functor which adds a dummy parameter to the passed functor.">sigc::hide()</a> returns can be directly passed into <a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2" title="Add a slot to the list of slots.">sigc::signal::connect()</a>.</p>
+<dl class="section user"><dt>Example:</dt><dd><div class="fragment"><div class="line"><a class="code" href="classsigc_1_1signal.html">sigc::signal<void,int></a> some_signal;</div>
+<div class="line"><span class="keywordtype">void</span> foo();</div>
+<div class="line">some_signal.<a class="code" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">connect</a>(<a class="code" href="group__hide.html#gaf2cefea3a99acd44f68121424103172d">sigc::hide</a>(&foo));</div>
+<div class="ttc" id="aclasssigc_1_1signal7_html_adc55ac9b0f935fd87a67904022e03cb2"><div class="ttname"><a href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">sigc::signal7::connect</a></div><div class="ttdeci">iterator connect(const slot_type &slot_)</div><div class="ttdoc">Add a slot to the list of slots.</div><div class="ttdef"><b>Definition:</b> signal.h:3871</div></div>
+<div class="ttc" id="aclasssigc_1_1signal_html"><div class="ttname"><a href="classsigc_1_1signal.html">sigc::signal</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::signal# templates.</div><div class="ttdef"><b>Definition:</b> signal.h:4015</div></div>
+</div><!-- fragment --></dd></dl>
+<p><a class="el" href="group__hide.html#gaf2cefea3a99acd44f68121424103172d" title="Creates an adaptor of type sigc::hide_functor which adds a dummy parameter to the passed functor.">sigc::hide()</a> can be nested in order to discard multiple arguments. </p><dl class="section user"><dt>Example:</dt><dd><div class="fragment"><div class="line"><span class="comment">// multiple argument hiding ...</span></div>
+<div class="line"><a class="code" href="group__hide.html#gaf2cefea3a99acd44f68121424103172d">sigc::hide</a>(<a class="code" href="group__hide.html#gaf2cefea3a99acd44f68121424103172d">sigc::hide</a>(&foo))(1,2,3,4); <span class="comment">// adds two dummy parameters at the back and calls foo(1,2)</span></div>
+</div><!-- fragment --></dd></dl>
+<p><a class="el" href="group__hide.html#gae4e6f5491471c12440f1c5d480726b98" title="Creates an adaptor of type sigc::retype_return_functor which drops the return value of the passed fun...">sigc::hide_return()</a> alters an arbitrary functor by dropping its return value, thus converting it to a void functor. </p>
+<h2 class="groupheader">Function Documentation</h2>
+<a id="gaf2cefea3a99acd44f68121424103172d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaf2cefea3a99acd44f68121424103172d">◆ </a></span>hide() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <int I_location, class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1hide__functor.html">hide_functor</a><I_location, T_functor> sigc::hide </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1hide__functor.html" title="Adaptor that adds a dummy parameter to the wrapped functor.">sigc::hide_functor</a> which adds a dummy parameter to the passed functor. </p>
+<p>The optional template argument <em>I_location</em> specifies the zero-based position of the dummy parameter in the returned functor (<code>-1</code> stands for the last parameter).</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_func</em>, ignoring the value of the dummy parameter. </dd></dl>
+
+</div>
+</div>
+<a id="gacbbacd3553268d85b95e3a85aefb67e5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gacbbacd3553268d85b95e3a85aefb67e5">◆ </a></span>hide() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1hide__functor.html">hide_functor</a><-1, T_functor> sigc::hide </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1hide__functor.html" title="Adaptor that adds a dummy parameter to the wrapped functor.">sigc::hide_functor</a> which adds a dummy parameter to the passed functor. </p>
+<p>This overload adds a dummy parameter at the back of the functor's parameter list.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_func</em>, ignoring the value of the last parameter. </dd></dl>
+
+</div>
+</div>
+<a id="gae4e6f5491471c12440f1c5d480726b98"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gae4e6f5491471c12440f1c5d480726b98">◆ </a></span>hide_return()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__return__functor.html">retype_return_functor</a><void, T_functor> sigc::hide_return </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__return__functor.html" title="Adaptor that performs a C-style cast on the return value of a functor.">sigc::retype_return_functor</a> which drops the return value of the passed functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> dropping its return value. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: mem_fun()</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#nested-classes">Classes</a> |
+<a href="#func-members">Functions</a> </div>
+ <div class="headertitle">
+<div class="title">mem_fun()<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> Creates a functor from a pointer to a method.
+<a href="#details">More...</a></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Classes</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html">sigc::bound_const_mem_functor0< T_return, T_obj ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html" title="bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance.">bound_const_mem_functor0</a> encapsulates a const method with 0 arguments and an object instance. <a href="classsigc_1_1bound__const__mem__functor0.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html">sigc::bound_const_mem_functor1< T_return, T_obj, T_arg1 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html" title="bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance.">bound_const_mem_functor1</a> encapsulates a const method with 1 arguments and an object instance. <a href="classsigc_1_1bound__const__mem__functor1.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html">sigc::bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html" title="bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance.">bound_const_mem_functor2</a> encapsulates a const method with 2 arguments and an object instance. <a href="classsigc_1_1bound__const__mem__functor2.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html">sigc::bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html" title="bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance.">bound_const_mem_functor3</a> encapsulates a const method with 3 arguments and an object instance. <a href="classsigc_1_1bound__const__mem__functor3.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html">sigc::bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html" title="bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance.">bound_const_mem_functor4</a> encapsulates a const method with 4 arguments and an object instance. <a href="classsigc_1_1bound__const__mem__functor4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html">sigc::bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html" title="bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance.">bound_const_mem_functor5</a> encapsulates a const method with 5 arguments and an object instance. <a href="classsigc_1_1bound__const__mem__functor5.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html">sigc::bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html" title="bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance.">bound_const_mem_functor6</a> encapsulates a const method with 6 arguments and an object instance. <a href="classsigc_1_1bound__const__mem__functor6.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html">sigc::bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html" title="bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance.">bound_const_mem_functor7</a> encapsulates a const method with 7 arguments and an object instance. <a href="classsigc_1_1bound__const__mem__functor7.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">sigc::bound_const_volatile_mem_functor0< T_return, T_obj ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html" title="bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object...">bound_const_volatile_mem_functor0</a> encapsulates a const volatile method with 0 arguments and an object instance. <a href="classsigc_1_1bound__const__volatile__mem__functor0.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">sigc::bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html" title="bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object...">bound_const_volatile_mem_functor1</a> encapsulates a const volatile method with 1 arguments and an object instance. <a href="classsigc_1_1bound__const__volatile__mem__functor1.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">sigc::bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html" title="bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object...">bound_const_volatile_mem_functor2</a> encapsulates a const volatile method with 2 arguments and an object instance. <a href="classsigc_1_1bound__const__volatile__mem__functor2.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">sigc::bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html" title="bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object...">bound_const_volatile_mem_functor3</a> encapsulates a const volatile method with 3 arguments and an object instance. <a href="classsigc_1_1bound__const__volatile__mem__functor3.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">sigc::bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html" title="bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object...">bound_const_volatile_mem_functor4</a> encapsulates a const volatile method with 4 arguments and an object instance. <a href="classsigc_1_1bound__const__volatile__mem__functor4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">sigc::bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html" title="bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object...">bound_const_volatile_mem_functor5</a> encapsulates a const volatile method with 5 arguments and an object instance. <a href="classsigc_1_1bound__const__volatile__mem__functor5.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">sigc::bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html" title="bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object...">bound_const_volatile_mem_functor6</a> encapsulates a const volatile method with 6 arguments and an object instance. <a href="classsigc_1_1bound__const__volatile__mem__functor6.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">sigc::bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html" title="bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object...">bound_const_volatile_mem_functor7</a> encapsulates a const volatile method with 7 arguments and an object instance. <a href="classsigc_1_1bound__const__volatile__mem__functor7.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor0.html">sigc::bound_mem_functor0< T_return, T_obj ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__mem__functor0.html" title="bound_mem_functor0 encapsulates a method with 0 arguments and an object instance.">bound_mem_functor0</a> encapsulates a method with 0 arguments and an object instance. <a href="classsigc_1_1bound__mem__functor0.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor1.html">sigc::bound_mem_functor1< T_return, T_obj, T_arg1 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__mem__functor1.html" title="bound_mem_functor1 encapsulates a method with 1 arguments and an object instance.">bound_mem_functor1</a> encapsulates a method with 1 arguments and an object instance. <a href="classsigc_1_1bound__mem__functor1.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor2.html">sigc::bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__mem__functor2.html" title="bound_mem_functor2 encapsulates a method with 2 arguments and an object instance.">bound_mem_functor2</a> encapsulates a method with 2 arguments and an object instance. <a href="classsigc_1_1bound__mem__functor2.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor3.html">sigc::bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__mem__functor3.html" title="bound_mem_functor3 encapsulates a method with 3 arguments and an object instance.">bound_mem_functor3</a> encapsulates a method with 3 arguments and an object instance. <a href="classsigc_1_1bound__mem__functor3.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor4.html">sigc::bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__mem__functor4.html" title="bound_mem_functor4 encapsulates a method with 4 arguments and an object instance.">bound_mem_functor4</a> encapsulates a method with 4 arguments and an object instance. <a href="classsigc_1_1bound__mem__functor4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor5.html">sigc::bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__mem__functor5.html" title="bound_mem_functor5 encapsulates a method with 5 arguments and an object instance.">bound_mem_functor5</a> encapsulates a method with 5 arguments and an object instance. <a href="classsigc_1_1bound__mem__functor5.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor6.html">sigc::bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__mem__functor6.html" title="bound_mem_functor6 encapsulates a method with 6 arguments and an object instance.">bound_mem_functor6</a> encapsulates a method with 6 arguments and an object instance. <a href="classsigc_1_1bound__mem__functor6.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor7.html">sigc::bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__mem__functor7.html" title="bound_mem_functor7 encapsulates a method with 7 arguments and an object instance.">bound_mem_functor7</a> encapsulates a method with 7 arguments and an object instance. <a href="classsigc_1_1bound__mem__functor7.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">sigc::bound_volatile_mem_functor0< T_return, T_obj ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html" title="bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance.">bound_volatile_mem_functor0</a> encapsulates a volatile method with 0 arguments and an object instance. <a href="classsigc_1_1bound__volatile__mem__functor0.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">sigc::bound_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html" title="bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance.">bound_volatile_mem_functor1</a> encapsulates a volatile method with 1 arguments and an object instance. <a href="classsigc_1_1bound__volatile__mem__functor1.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">sigc::bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html" title="bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance.">bound_volatile_mem_functor2</a> encapsulates a volatile method with 2 arguments and an object instance. <a href="classsigc_1_1bound__volatile__mem__functor2.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">sigc::bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html" title="bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance.">bound_volatile_mem_functor3</a> encapsulates a volatile method with 3 arguments and an object instance. <a href="classsigc_1_1bound__volatile__mem__functor3.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">sigc::bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html" title="bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance.">bound_volatile_mem_functor4</a> encapsulates a volatile method with 4 arguments and an object instance. <a href="classsigc_1_1bound__volatile__mem__functor4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">sigc::bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html" title="bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance.">bound_volatile_mem_functor5</a> encapsulates a volatile method with 5 arguments and an object instance. <a href="classsigc_1_1bound__volatile__mem__functor5.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">sigc::bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html" title="bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance.">bound_volatile_mem_functor6</a> encapsulates a volatile method with 6 arguments and an object instance. <a href="classsigc_1_1bound__volatile__mem__functor6.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">sigc::bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html" title="bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance.">bound_volatile_mem_functor7</a> encapsulates a volatile method with 7 arguments and an object instance. <a href="classsigc_1_1bound__volatile__mem__functor7.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor0.html">sigc::const_mem_functor0< T_return, T_obj ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__mem__functor0.html" title="const_mem_functor0 wraps const methods with 0 argument(s).">const_mem_functor0</a> wraps const methods with 0 argument(s). <a href="classsigc_1_1const__mem__functor0.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor1.html">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__mem__functor1.html" title="const_mem_functor1 wraps const methods with 1 argument(s).">const_mem_functor1</a> wraps const methods with 1 argument(s). <a href="classsigc_1_1const__mem__functor1.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor2.html">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__mem__functor2.html" title="const_mem_functor2 wraps const methods with 2 argument(s).">const_mem_functor2</a> wraps const methods with 2 argument(s). <a href="classsigc_1_1const__mem__functor2.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor3.html">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__mem__functor3.html" title="const_mem_functor3 wraps const methods with 3 argument(s).">const_mem_functor3</a> wraps const methods with 3 argument(s). <a href="classsigc_1_1const__mem__functor3.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor4.html">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__mem__functor4.html" title="const_mem_functor4 wraps const methods with 4 argument(s).">const_mem_functor4</a> wraps const methods with 4 argument(s). <a href="classsigc_1_1const__mem__functor4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor5.html">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__mem__functor5.html" title="const_mem_functor5 wraps const methods with 5 argument(s).">const_mem_functor5</a> wraps const methods with 5 argument(s). <a href="classsigc_1_1const__mem__functor5.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor6.html">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__mem__functor6.html" title="const_mem_functor6 wraps const methods with 6 argument(s).">const_mem_functor6</a> wraps const methods with 6 argument(s). <a href="classsigc_1_1const__mem__functor6.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor7.html">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__mem__functor7.html" title="const_mem_functor7 wraps const methods with 7 argument(s).">const_mem_functor7</a> wraps const methods with 7 argument(s). <a href="classsigc_1_1const__mem__functor7.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">sigc::const_volatile_mem_functor0< T_return, T_obj ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html" title="const_volatile_mem_functor0 wraps const volatile methods with 0 argument(s).">const_volatile_mem_functor0</a> wraps const volatile methods with 0 argument(s). <a href="classsigc_1_1const__volatile__mem__functor0.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html" title="const_volatile_mem_functor1 wraps const volatile methods with 1 argument(s).">const_volatile_mem_functor1</a> wraps const volatile methods with 1 argument(s). <a href="classsigc_1_1const__volatile__mem__functor1.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html" title="const_volatile_mem_functor2 wraps const volatile methods with 2 argument(s).">const_volatile_mem_functor2</a> wraps const volatile methods with 2 argument(s). <a href="classsigc_1_1const__volatile__mem__functor2.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html" title="const_volatile_mem_functor3 wraps const volatile methods with 3 argument(s).">const_volatile_mem_functor3</a> wraps const volatile methods with 3 argument(s). <a href="classsigc_1_1const__volatile__mem__functor3.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html" title="const_volatile_mem_functor4 wraps const volatile methods with 4 argument(s).">const_volatile_mem_functor4</a> wraps const volatile methods with 4 argument(s). <a href="classsigc_1_1const__volatile__mem__functor4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html" title="const_volatile_mem_functor5 wraps const volatile methods with 5 argument(s).">const_volatile_mem_functor5</a> wraps const volatile methods with 5 argument(s). <a href="classsigc_1_1const__volatile__mem__functor5.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html" title="const_volatile_mem_functor6 wraps const volatile methods with 6 argument(s).">const_volatile_mem_functor6</a> wraps const volatile methods with 6 argument(s). <a href="classsigc_1_1const__volatile__mem__functor6.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html" title="const_volatile_mem_functor7 wraps const volatile methods with 7 argument(s).">const_volatile_mem_functor7</a> wraps const volatile methods with 7 argument(s). <a href="classsigc_1_1const__volatile__mem__functor7.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor0.html">sigc::mem_functor0< T_return, T_obj ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1mem__functor0.html" title="mem_functor0 wraps methods with 0 argument(s).">mem_functor0</a> wraps methods with 0 argument(s). <a href="classsigc_1_1mem__functor0.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor1.html">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1mem__functor1.html" title="mem_functor1 wraps methods with 1 argument(s).">mem_functor1</a> wraps methods with 1 argument(s). <a href="classsigc_1_1mem__functor1.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor2.html">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1mem__functor2.html" title="mem_functor2 wraps methods with 2 argument(s).">mem_functor2</a> wraps methods with 2 argument(s). <a href="classsigc_1_1mem__functor2.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor3.html">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1mem__functor3.html" title="mem_functor3 wraps methods with 3 argument(s).">mem_functor3</a> wraps methods with 3 argument(s). <a href="classsigc_1_1mem__functor3.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor4.html">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1mem__functor4.html" title="mem_functor4 wraps methods with 4 argument(s).">mem_functor4</a> wraps methods with 4 argument(s). <a href="classsigc_1_1mem__functor4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor5.html">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1mem__functor5.html" title="mem_functor5 wraps methods with 5 argument(s).">mem_functor5</a> wraps methods with 5 argument(s). <a href="classsigc_1_1mem__functor5.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor6.html">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1mem__functor6.html" title="mem_functor6 wraps methods with 6 argument(s).">mem_functor6</a> wraps methods with 6 argument(s). <a href="classsigc_1_1mem__functor6.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor7.html">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1mem__functor7.html" title="mem_functor7 wraps methods with 7 argument(s).">mem_functor7</a> wraps methods with 7 argument(s). <a href="classsigc_1_1mem__functor7.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor0.html">sigc::volatile_mem_functor0< T_return, T_obj ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1volatile__mem__functor0.html" title="volatile_mem_functor0 wraps volatile methods with 0 argument(s).">volatile_mem_functor0</a> wraps volatile methods with 0 argument(s). <a href="classsigc_1_1volatile__mem__functor0.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor1.html">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1volatile__mem__functor1.html" title="volatile_mem_functor1 wraps volatile methods with 1 argument(s).">volatile_mem_functor1</a> wraps volatile methods with 1 argument(s). <a href="classsigc_1_1volatile__mem__functor1.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor2.html">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1volatile__mem__functor2.html" title="volatile_mem_functor2 wraps volatile methods with 2 argument(s).">volatile_mem_functor2</a> wraps volatile methods with 2 argument(s). <a href="classsigc_1_1volatile__mem__functor2.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor3.html">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1volatile__mem__functor3.html" title="volatile_mem_functor3 wraps volatile methods with 3 argument(s).">volatile_mem_functor3</a> wraps volatile methods with 3 argument(s). <a href="classsigc_1_1volatile__mem__functor3.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor4.html">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1volatile__mem__functor4.html" title="volatile_mem_functor4 wraps volatile methods with 4 argument(s).">volatile_mem_functor4</a> wraps volatile methods with 4 argument(s). <a href="classsigc_1_1volatile__mem__functor4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor5.html">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1volatile__mem__functor5.html" title="volatile_mem_functor5 wraps volatile methods with 5 argument(s).">volatile_mem_functor5</a> wraps volatile methods with 5 argument(s). <a href="classsigc_1_1volatile__mem__functor5.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor6.html">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1volatile__mem__functor6.html" title="volatile_mem_functor6 wraps volatile methods with 6 argument(s).">volatile_mem_functor6</a> wraps volatile methods with 6 argument(s). <a href="classsigc_1_1volatile__mem__functor6.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor7.html">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1volatile__mem__functor7.html" title="volatile_mem_functor7 wraps volatile methods with 7 argument(s).">volatile_mem_functor7</a> wraps volatile methods with 7 argument(s). <a href="classsigc_1_1volatile__mem__functor7.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
+Functions</h2></td></tr>
+<tr class="memitem:gaeef6e55681664df29b31edec51ea034d"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaeef6e55681664df29b31edec51ea034d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor0.html">bound_mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gaeef6e55681664df29b31edec51ea034d">sigc::mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)())</td></tr>
+<tr class="memdesc:gaeef6e55681664df29b31edec51ea034d"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor0.html" title="bound_mem_functor0 encapsulates a method with 0 arguments and an object instance.">sigc::bound_mem_functor0</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#gaeef6e55681664df29b31edec51ea034d">More...</a><br /></td></tr>
+<tr class="separator:gaeef6e55681664df29b31edec51ea034d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga7de39a04dfc6d37b2d12a25cdccfbe95"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga7de39a04dfc6d37b2d12a25cdccfbe95"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor1.html">bound_mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga7de39a04dfc6d37b2d12a25cdccfbe95">sigc::mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1))</td></tr>
+<tr class="memdesc:ga7de39a04dfc6d37b2d12a25cdccfbe95"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor1.html" title="bound_mem_functor1 encapsulates a method with 1 arguments and an object instance.">sigc::bound_mem_functor1</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga7de39a04dfc6d37b2d12a25cdccfbe95">More...</a><br /></td></tr>
+<tr class="separator:ga7de39a04dfc6d37b2d12a25cdccfbe95"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gab1add5c927b51b935b4f2d40558079fa"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gab1add5c927b51b935b4f2d40558079fa"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor2.html">bound_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gab1add5c927b51b935b4f2d40558079fa">sigc::mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2))</td></tr>
+<tr class="memdesc:gab1add5c927b51b935b4f2d40558079fa"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor2.html" title="bound_mem_functor2 encapsulates a method with 2 arguments and an object instance.">sigc::bound_mem_functor2</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#gab1add5c927b51b935b4f2d40558079fa">More...</a><br /></td></tr>
+<tr class="separator:gab1add5c927b51b935b4f2d40558079fa"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga1f1aa3b60c0d2d8b2470bba0b2b36023"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga1f1aa3b60c0d2d8b2470bba0b2b36023"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor3.html">bound_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga1f1aa3b60c0d2d8b2470bba0b2b36023">sigc::mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3))</td></tr>
+<tr class="memdesc:ga1f1aa3b60c0d2d8b2470bba0b2b36023"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor3.html" title="bound_mem_functor3 encapsulates a method with 3 arguments and an object instance.">sigc::bound_mem_functor3</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga1f1aa3b60c0d2d8b2470bba0b2b36023">More...</a><br /></td></tr>
+<tr class="separator:ga1f1aa3b60c0d2d8b2470bba0b2b36023"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga481ef34d8423d26e8ff0a1916cd295d5"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga481ef34d8423d26e8ff0a1916cd295d5"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor4.html">bound_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga481ef34d8423d26e8ff0a1916cd295d5">sigc::mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</td></tr>
+<tr class="memdesc:ga481ef34d8423d26e8ff0a1916cd295d5"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor4.html" title="bound_mem_functor4 encapsulates a method with 4 arguments and an object instance.">sigc::bound_mem_functor4</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga481ef34d8423d26e8ff0a1916cd295d5">More...</a><br /></td></tr>
+<tr class="separator:ga481ef34d8423d26e8ff0a1916cd295d5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga09fb13b1684ec7c092ffef695dbb261a"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga09fb13b1684ec7c092ffef695dbb261a"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor5.html">bound_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga09fb13b1684ec7c092ffef695dbb261a">sigc::mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</td></tr>
+<tr class="memdesc:ga09fb13b1684ec7c092ffef695dbb261a"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor5.html" title="bound_mem_functor5 encapsulates a method with 5 arguments and an object instance.">sigc::bound_mem_functor5</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga09fb13b1684ec7c092ffef695dbb261a">More...</a><br /></td></tr>
+<tr class="separator:ga09fb13b1684ec7c092ffef695dbb261a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga0d9b992d69123a524b6c70c458ad0d40"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga0d9b992d69123a524b6c70c458ad0d40"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor6.html">bound_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga0d9b992d69123a524b6c70c458ad0d40">sigc::mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</td></tr>
+<tr class="memdesc:ga0d9b992d69123a524b6c70c458ad0d40"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor6.html" title="bound_mem_functor6 encapsulates a method with 6 arguments and an object instance.">sigc::bound_mem_functor6</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga0d9b992d69123a524b6c70c458ad0d40">More...</a><br /></td></tr>
+<tr class="separator:ga0d9b992d69123a524b6c70c458ad0d40"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga5dcdaf235baa50049e6088d246853037"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga5dcdaf235baa50049e6088d246853037"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor7.html">bound_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga5dcdaf235baa50049e6088d246853037">sigc::mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</td></tr>
+<tr class="memdesc:ga5dcdaf235baa50049e6088d246853037"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor7.html" title="bound_mem_functor7 encapsulates a method with 7 arguments and an object instance.">sigc::bound_mem_functor7</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga5dcdaf235baa50049e6088d246853037">More...</a><br /></td></tr>
+<tr class="separator:ga5dcdaf235baa50049e6088d246853037"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga7f57ec0156d33b4aa98e259d2e2062db"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga7f57ec0156d33b4aa98e259d2e2062db"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor0.html">bound_mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga7f57ec0156d33b4aa98e259d2e2062db">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)())</td></tr>
+<tr class="memdesc:ga7f57ec0156d33b4aa98e259d2e2062db"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor0.html" title="bound_mem_functor0 encapsulates a method with 0 arguments and an object instance.">sigc::bound_mem_functor0</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga7f57ec0156d33b4aa98e259d2e2062db">More...</a><br /></td></tr>
+<tr class="separator:ga7f57ec0156d33b4aa98e259d2e2062db"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga0df7af9f32990cc624c4bb60782b4f78"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga0df7af9f32990cc624c4bb60782b4f78"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor1.html">bound_mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga0df7af9f32990cc624c4bb60782b4f78">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1))</td></tr>
+<tr class="memdesc:ga0df7af9f32990cc624c4bb60782b4f78"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor1.html" title="bound_mem_functor1 encapsulates a method with 1 arguments and an object instance.">sigc::bound_mem_functor1</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga0df7af9f32990cc624c4bb60782b4f78">More...</a><br /></td></tr>
+<tr class="separator:ga0df7af9f32990cc624c4bb60782b4f78"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga118b2610268701be95cdc6fddb7bab3b"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga118b2610268701be95cdc6fddb7bab3b"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor2.html">bound_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga118b2610268701be95cdc6fddb7bab3b">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2))</td></tr>
+<tr class="memdesc:ga118b2610268701be95cdc6fddb7bab3b"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor2.html" title="bound_mem_functor2 encapsulates a method with 2 arguments and an object instance.">sigc::bound_mem_functor2</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga118b2610268701be95cdc6fddb7bab3b">More...</a><br /></td></tr>
+<tr class="separator:ga118b2610268701be95cdc6fddb7bab3b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaeb6bd4518e0f0c524dba13a6cbb2e319"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaeb6bd4518e0f0c524dba13a6cbb2e319"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor3.html">bound_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gaeb6bd4518e0f0c524dba13a6cbb2e319">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3))</td></tr>
+<tr class="memdesc:gaeb6bd4518e0f0c524dba13a6cbb2e319"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor3.html" title="bound_mem_functor3 encapsulates a method with 3 arguments and an object instance.">sigc::bound_mem_functor3</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#gaeb6bd4518e0f0c524dba13a6cbb2e319">More...</a><br /></td></tr>
+<tr class="separator:gaeb6bd4518e0f0c524dba13a6cbb2e319"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga02c906c95895c58e39ee301bb1577994"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga02c906c95895c58e39ee301bb1577994"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor4.html">bound_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga02c906c95895c58e39ee301bb1577994">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</td></tr>
+<tr class="memdesc:ga02c906c95895c58e39ee301bb1577994"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor4.html" title="bound_mem_functor4 encapsulates a method with 4 arguments and an object instance.">sigc::bound_mem_functor4</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga02c906c95895c58e39ee301bb1577994">More...</a><br /></td></tr>
+<tr class="separator:ga02c906c95895c58e39ee301bb1577994"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gab138ae1a340be983166b69872826b37d"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gab138ae1a340be983166b69872826b37d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor5.html">bound_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gab138ae1a340be983166b69872826b37d">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</td></tr>
+<tr class="memdesc:gab138ae1a340be983166b69872826b37d"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor5.html" title="bound_mem_functor5 encapsulates a method with 5 arguments and an object instance.">sigc::bound_mem_functor5</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#gab138ae1a340be983166b69872826b37d">More...</a><br /></td></tr>
+<tr class="separator:gab138ae1a340be983166b69872826b37d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga3e3841c4844715d2f2d832ed506f028f"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga3e3841c4844715d2f2d832ed506f028f"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor6.html">bound_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga3e3841c4844715d2f2d832ed506f028f">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</td></tr>
+<tr class="memdesc:ga3e3841c4844715d2f2d832ed506f028f"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor6.html" title="bound_mem_functor6 encapsulates a method with 6 arguments and an object instance.">sigc::bound_mem_functor6</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga3e3841c4844715d2f2d832ed506f028f">More...</a><br /></td></tr>
+<tr class="separator:ga3e3841c4844715d2f2d832ed506f028f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaea5a2ace2699b8d1ffe93585e335548d"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaea5a2ace2699b8d1ffe93585e335548d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor7.html">bound_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gaea5a2ace2699b8d1ffe93585e335548d">sigc::mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</td></tr>
+<tr class="memdesc:gaea5a2ace2699b8d1ffe93585e335548d"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor7.html" title="bound_mem_functor7 encapsulates a method with 7 arguments and an object instance.">sigc::bound_mem_functor7</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#gaea5a2ace2699b8d1ffe93585e335548d">More...</a><br /></td></tr>
+<tr class="separator:gaea5a2ace2699b8d1ffe93585e335548d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gadf6b6d22c503b439019f0a2e77352419"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj > </td></tr>
+<tr class="memitem:gadf6b6d22c503b439019f0a2e77352419"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor0.html">mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">sigc::mem_fun</a> (T_return(T_obj::* _A_func)())</td></tr>
+<tr class="memdesc:gadf6b6d22c503b439019f0a2e77352419"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor0.html" title="mem_functor0 wraps methods with 0 argument(s).">sigc::mem_functor0</a> which wraps a method. <a href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">More...</a><br /></td></tr>
+<tr class="separator:gadf6b6d22c503b439019f0a2e77352419"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gab661fef0f04e2e439912eee6989e9657"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gab661fef0f04e2e439912eee6989e9657"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor1.html">mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gab661fef0f04e2e439912eee6989e9657">sigc::mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1))</td></tr>
+<tr class="memdesc:gab661fef0f04e2e439912eee6989e9657"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor1.html" title="mem_functor1 wraps methods with 1 argument(s).">sigc::mem_functor1</a> which wraps a method. <a href="group__mem__fun.html#gab661fef0f04e2e439912eee6989e9657">More...</a><br /></td></tr>
+<tr class="separator:gab661fef0f04e2e439912eee6989e9657"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor2.html">mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5">sigc::mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2))</td></tr>
+<tr class="memdesc:ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor2.html" title="mem_functor2 wraps methods with 2 argument(s).">sigc::mem_functor2</a> which wraps a method. <a href="group__mem__fun.html#ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5">More...</a><br /></td></tr>
+<tr class="separator:ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaa3778234963fa65d4f638856d91109d1"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gaa3778234963fa65d4f638856d91109d1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor3.html">mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gaa3778234963fa65d4f638856d91109d1">sigc::mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3))</td></tr>
+<tr class="memdesc:gaa3778234963fa65d4f638856d91109d1"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor3.html" title="mem_functor3 wraps methods with 3 argument(s).">sigc::mem_functor3</a> which wraps a method. <a href="group__mem__fun.html#gaa3778234963fa65d4f638856d91109d1">More...</a><br /></td></tr>
+<tr class="separator:gaa3778234963fa65d4f638856d91109d1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gadadd40aba6dadd0edbaac609dfae3938"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gadadd40aba6dadd0edbaac609dfae3938"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor4.html">mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gadadd40aba6dadd0edbaac609dfae3938">sigc::mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</td></tr>
+<tr class="memdesc:gadadd40aba6dadd0edbaac609dfae3938"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor4.html" title="mem_functor4 wraps methods with 4 argument(s).">sigc::mem_functor4</a> which wraps a method. <a href="group__mem__fun.html#gadadd40aba6dadd0edbaac609dfae3938">More...</a><br /></td></tr>
+<tr class="separator:gadadd40aba6dadd0edbaac609dfae3938"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaa01df6c622d59cfd2d0d8aa3c04c36d1"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gaa01df6c622d59cfd2d0d8aa3c04c36d1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor5.html">mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gaa01df6c622d59cfd2d0d8aa3c04c36d1">sigc::mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</td></tr>
+<tr class="memdesc:gaa01df6c622d59cfd2d0d8aa3c04c36d1"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor5.html" title="mem_functor5 wraps methods with 5 argument(s).">sigc::mem_functor5</a> which wraps a method. <a href="group__mem__fun.html#gaa01df6c622d59cfd2d0d8aa3c04c36d1">More...</a><br /></td></tr>
+<tr class="separator:gaa01df6c622d59cfd2d0d8aa3c04c36d1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga9030b647c35e06c68342fee34e8fd320"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga9030b647c35e06c68342fee34e8fd320"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor6.html">mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga9030b647c35e06c68342fee34e8fd320">sigc::mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</td></tr>
+<tr class="memdesc:ga9030b647c35e06c68342fee34e8fd320"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor6.html" title="mem_functor6 wraps methods with 6 argument(s).">sigc::mem_functor6</a> which wraps a method. <a href="group__mem__fun.html#ga9030b647c35e06c68342fee34e8fd320">More...</a><br /></td></tr>
+<tr class="separator:ga9030b647c35e06c68342fee34e8fd320"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga54e4bf947e8c93c56931b8e8f7ed0d2e"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga54e4bf947e8c93c56931b8e8f7ed0d2e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor7.html">mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga54e4bf947e8c93c56931b8e8f7ed0d2e">sigc::mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</td></tr>
+<tr class="memdesc:ga54e4bf947e8c93c56931b8e8f7ed0d2e"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor7.html" title="mem_functor7 wraps methods with 7 argument(s).">sigc::mem_functor7</a> which wraps a method. <a href="group__mem__fun.html#ga54e4bf947e8c93c56931b8e8f7ed0d2e">More...</a><br /></td></tr>
+<tr class="separator:ga54e4bf947e8c93c56931b8e8f7ed0d2e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaf71277763f14050e2d270fcf3ea41dc9"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaf71277763f14050e2d270fcf3ea41dc9"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor0.html">bound_mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gaf71277763f14050e2d270fcf3ea41dc9">sigc::mem_fun0</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)())</td></tr>
+<tr class="memdesc:gaf71277763f14050e2d270fcf3ea41dc9"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor0.html" title="bound_mem_functor0 encapsulates a method with 0 arguments and an object instance.">sigc::bound_mem_functor0</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#gaf71277763f14050e2d270fcf3ea41dc9">More...</a><br /></td></tr>
+<tr class="separator:gaf71277763f14050e2d270fcf3ea41dc9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gae03d0b73b85e85d2ad8bc43b19b855e3"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gae03d0b73b85e85d2ad8bc43b19b855e3"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor0.html">bound_mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gae03d0b73b85e85d2ad8bc43b19b855e3">sigc::mem_fun0</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)())</td></tr>
+<tr class="memdesc:gae03d0b73b85e85d2ad8bc43b19b855e3"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor0.html" title="bound_mem_functor0 encapsulates a method with 0 arguments and an object instance.">sigc::bound_mem_functor0</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#gae03d0b73b85e85d2ad8bc43b19b855e3">More...</a><br /></td></tr>
+<tr class="separator:gae03d0b73b85e85d2ad8bc43b19b855e3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga765b35689a909fbc2a627be8256c5b1f"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga765b35689a909fbc2a627be8256c5b1f"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor0.html">mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga765b35689a909fbc2a627be8256c5b1f">sigc::mem_fun0</a> (T_return(T_obj::* _A_func)())</td></tr>
+<tr class="memdesc:ga765b35689a909fbc2a627be8256c5b1f"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor0.html" title="mem_functor0 wraps methods with 0 argument(s).">sigc::mem_functor0</a> which wraps a method. <a href="group__mem__fun.html#ga765b35689a909fbc2a627be8256c5b1f">More...</a><br /></td></tr>
+<tr class="separator:ga765b35689a909fbc2a627be8256c5b1f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaade596a4dacfd1429039525bb9f399d0"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaade596a4dacfd1429039525bb9f399d0"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor1.html">bound_mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gaade596a4dacfd1429039525bb9f399d0">sigc::mem_fun1</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1))</td></tr>
+<tr class="memdesc:gaade596a4dacfd1429039525bb9f399d0"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor1.html" title="bound_mem_functor1 encapsulates a method with 1 arguments and an object instance.">sigc::bound_mem_functor1</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#gaade596a4dacfd1429039525bb9f399d0">More...</a><br /></td></tr>
+<tr class="separator:gaade596a4dacfd1429039525bb9f399d0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga3dd8d2ed97310dbf4fa394999f0be7b7"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga3dd8d2ed97310dbf4fa394999f0be7b7"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor1.html">bound_mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga3dd8d2ed97310dbf4fa394999f0be7b7">sigc::mem_fun1</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1))</td></tr>
+<tr class="memdesc:ga3dd8d2ed97310dbf4fa394999f0be7b7"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor1.html" title="bound_mem_functor1 encapsulates a method with 1 arguments and an object instance.">sigc::bound_mem_functor1</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga3dd8d2ed97310dbf4fa394999f0be7b7">More...</a><br /></td></tr>
+<tr class="separator:ga3dd8d2ed97310dbf4fa394999f0be7b7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gae0bebf0d8a2d36d93746c23d9eea668d"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gae0bebf0d8a2d36d93746c23d9eea668d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor1.html">mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gae0bebf0d8a2d36d93746c23d9eea668d">sigc::mem_fun1</a> (T_return(T_obj::* _A_func)(T_arg1))</td></tr>
+<tr class="memdesc:gae0bebf0d8a2d36d93746c23d9eea668d"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor1.html" title="mem_functor1 wraps methods with 1 argument(s).">sigc::mem_functor1</a> which wraps a method. <a href="group__mem__fun.html#gae0bebf0d8a2d36d93746c23d9eea668d">More...</a><br /></td></tr>
+<tr class="separator:gae0bebf0d8a2d36d93746c23d9eea668d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaee7652f1a0625df50af50e28b5e2423e"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaee7652f1a0625df50af50e28b5e2423e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor2.html">bound_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gaee7652f1a0625df50af50e28b5e2423e">sigc::mem_fun2</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2))</td></tr>
+<tr class="memdesc:gaee7652f1a0625df50af50e28b5e2423e"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor2.html" title="bound_mem_functor2 encapsulates a method with 2 arguments and an object instance.">sigc::bound_mem_functor2</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#gaee7652f1a0625df50af50e28b5e2423e">More...</a><br /></td></tr>
+<tr class="separator:gaee7652f1a0625df50af50e28b5e2423e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga184da4166c8b5409dc4b98d7bc16dff8"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga184da4166c8b5409dc4b98d7bc16dff8"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor2.html">bound_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga184da4166c8b5409dc4b98d7bc16dff8">sigc::mem_fun2</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2))</td></tr>
+<tr class="memdesc:ga184da4166c8b5409dc4b98d7bc16dff8"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor2.html" title="bound_mem_functor2 encapsulates a method with 2 arguments and an object instance.">sigc::bound_mem_functor2</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga184da4166c8b5409dc4b98d7bc16dff8">More...</a><br /></td></tr>
+<tr class="separator:ga184da4166c8b5409dc4b98d7bc16dff8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gab76f41aeada332b353b6fe2e96008831"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gab76f41aeada332b353b6fe2e96008831"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor2.html">mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gab76f41aeada332b353b6fe2e96008831">sigc::mem_fun2</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2))</td></tr>
+<tr class="memdesc:gab76f41aeada332b353b6fe2e96008831"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor2.html" title="mem_functor2 wraps methods with 2 argument(s).">sigc::mem_functor2</a> which wraps a method. <a href="group__mem__fun.html#gab76f41aeada332b353b6fe2e96008831">More...</a><br /></td></tr>
+<tr class="separator:gab76f41aeada332b353b6fe2e96008831"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga14e07df139b5cb6897e671c50fc33cde"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga14e07df139b5cb6897e671c50fc33cde"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor3.html">bound_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga14e07df139b5cb6897e671c50fc33cde">sigc::mem_fun3</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3))</td></tr>
+<tr class="memdesc:ga14e07df139b5cb6897e671c50fc33cde"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor3.html" title="bound_mem_functor3 encapsulates a method with 3 arguments and an object instance.">sigc::bound_mem_functor3</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga14e07df139b5cb6897e671c50fc33cde">More...</a><br /></td></tr>
+<tr class="separator:ga14e07df139b5cb6897e671c50fc33cde"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga4f2fdbf02e8cac9492326a4a8ffdd012"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga4f2fdbf02e8cac9492326a4a8ffdd012"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor3.html">bound_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga4f2fdbf02e8cac9492326a4a8ffdd012">sigc::mem_fun3</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3))</td></tr>
+<tr class="memdesc:ga4f2fdbf02e8cac9492326a4a8ffdd012"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor3.html" title="bound_mem_functor3 encapsulates a method with 3 arguments and an object instance.">sigc::bound_mem_functor3</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga4f2fdbf02e8cac9492326a4a8ffdd012">More...</a><br /></td></tr>
+<tr class="separator:ga4f2fdbf02e8cac9492326a4a8ffdd012"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga2379e0d689fe4a99c7c669fc29817457"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga2379e0d689fe4a99c7c669fc29817457"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor3.html">mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga2379e0d689fe4a99c7c669fc29817457">sigc::mem_fun3</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3))</td></tr>
+<tr class="memdesc:ga2379e0d689fe4a99c7c669fc29817457"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor3.html" title="mem_functor3 wraps methods with 3 argument(s).">sigc::mem_functor3</a> which wraps a method. <a href="group__mem__fun.html#ga2379e0d689fe4a99c7c669fc29817457">More...</a><br /></td></tr>
+<tr class="separator:ga2379e0d689fe4a99c7c669fc29817457"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga86da5637e2735480d525ffa930e7e21a"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga86da5637e2735480d525ffa930e7e21a"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor4.html">bound_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga86da5637e2735480d525ffa930e7e21a">sigc::mem_fun4</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</td></tr>
+<tr class="memdesc:ga86da5637e2735480d525ffa930e7e21a"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor4.html" title="bound_mem_functor4 encapsulates a method with 4 arguments and an object instance.">sigc::bound_mem_functor4</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga86da5637e2735480d525ffa930e7e21a">More...</a><br /></td></tr>
+<tr class="separator:ga86da5637e2735480d525ffa930e7e21a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga94a2525ef116e16598b81b853544a170"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga94a2525ef116e16598b81b853544a170"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor4.html">bound_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga94a2525ef116e16598b81b853544a170">sigc::mem_fun4</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</td></tr>
+<tr class="memdesc:ga94a2525ef116e16598b81b853544a170"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor4.html" title="bound_mem_functor4 encapsulates a method with 4 arguments and an object instance.">sigc::bound_mem_functor4</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga94a2525ef116e16598b81b853544a170">More...</a><br /></td></tr>
+<tr class="separator:ga94a2525ef116e16598b81b853544a170"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga1bedd04f76ad3e21f614912562e95d83"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga1bedd04f76ad3e21f614912562e95d83"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor4.html">mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga1bedd04f76ad3e21f614912562e95d83">sigc::mem_fun4</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</td></tr>
+<tr class="memdesc:ga1bedd04f76ad3e21f614912562e95d83"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor4.html" title="mem_functor4 wraps methods with 4 argument(s).">sigc::mem_functor4</a> which wraps a method. <a href="group__mem__fun.html#ga1bedd04f76ad3e21f614912562e95d83">More...</a><br /></td></tr>
+<tr class="separator:ga1bedd04f76ad3e21f614912562e95d83"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga5c2ca9cef8c857935a59133a73ef61f2"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga5c2ca9cef8c857935a59133a73ef61f2"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor5.html">bound_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga5c2ca9cef8c857935a59133a73ef61f2">sigc::mem_fun5</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</td></tr>
+<tr class="memdesc:ga5c2ca9cef8c857935a59133a73ef61f2"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor5.html" title="bound_mem_functor5 encapsulates a method with 5 arguments and an object instance.">sigc::bound_mem_functor5</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga5c2ca9cef8c857935a59133a73ef61f2">More...</a><br /></td></tr>
+<tr class="separator:ga5c2ca9cef8c857935a59133a73ef61f2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaf060fe3a2be4ff7c0f50aef54b4dc8bf"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaf060fe3a2be4ff7c0f50aef54b4dc8bf"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor5.html">bound_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gaf060fe3a2be4ff7c0f50aef54b4dc8bf">sigc::mem_fun5</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</td></tr>
+<tr class="memdesc:gaf060fe3a2be4ff7c0f50aef54b4dc8bf"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor5.html" title="bound_mem_functor5 encapsulates a method with 5 arguments and an object instance.">sigc::bound_mem_functor5</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#gaf060fe3a2be4ff7c0f50aef54b4dc8bf">More...</a><br /></td></tr>
+<tr class="separator:gaf060fe3a2be4ff7c0f50aef54b4dc8bf"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga3ef4bb904a751d29e2b6803ef81f72fa"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga3ef4bb904a751d29e2b6803ef81f72fa"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor5.html">mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga3ef4bb904a751d29e2b6803ef81f72fa">sigc::mem_fun5</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</td></tr>
+<tr class="memdesc:ga3ef4bb904a751d29e2b6803ef81f72fa"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor5.html" title="mem_functor5 wraps methods with 5 argument(s).">sigc::mem_functor5</a> which wraps a method. <a href="group__mem__fun.html#ga3ef4bb904a751d29e2b6803ef81f72fa">More...</a><br /></td></tr>
+<tr class="separator:ga3ef4bb904a751d29e2b6803ef81f72fa"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga947f4410e62a2996023177e490c882b7"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga947f4410e62a2996023177e490c882b7"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor6.html">bound_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga947f4410e62a2996023177e490c882b7">sigc::mem_fun6</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</td></tr>
+<tr class="memdesc:ga947f4410e62a2996023177e490c882b7"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor6.html" title="bound_mem_functor6 encapsulates a method with 6 arguments and an object instance.">sigc::bound_mem_functor6</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga947f4410e62a2996023177e490c882b7">More...</a><br /></td></tr>
+<tr class="separator:ga947f4410e62a2996023177e490c882b7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gac0a6242da9bf96642f25c1363dfef383"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gac0a6242da9bf96642f25c1363dfef383"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor6.html">bound_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gac0a6242da9bf96642f25c1363dfef383">sigc::mem_fun6</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</td></tr>
+<tr class="memdesc:gac0a6242da9bf96642f25c1363dfef383"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor6.html" title="bound_mem_functor6 encapsulates a method with 6 arguments and an object instance.">sigc::bound_mem_functor6</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#gac0a6242da9bf96642f25c1363dfef383">More...</a><br /></td></tr>
+<tr class="separator:gac0a6242da9bf96642f25c1363dfef383"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga34ace98fbbd18cb635795639d0f22678"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga34ace98fbbd18cb635795639d0f22678"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor6.html">mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga34ace98fbbd18cb635795639d0f22678">sigc::mem_fun6</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</td></tr>
+<tr class="memdesc:ga34ace98fbbd18cb635795639d0f22678"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor6.html" title="mem_functor6 wraps methods with 6 argument(s).">sigc::mem_functor6</a> which wraps a method. <a href="group__mem__fun.html#ga34ace98fbbd18cb635795639d0f22678">More...</a><br /></td></tr>
+<tr class="separator:ga34ace98fbbd18cb635795639d0f22678"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga1f704e475da2aad1717e059c264c1436"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga1f704e475da2aad1717e059c264c1436"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor7.html">bound_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga1f704e475da2aad1717e059c264c1436">sigc::mem_fun7</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</td></tr>
+<tr class="memdesc:ga1f704e475da2aad1717e059c264c1436"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor7.html" title="bound_mem_functor7 encapsulates a method with 7 arguments and an object instance.">sigc::bound_mem_functor7</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga1f704e475da2aad1717e059c264c1436">More...</a><br /></td></tr>
+<tr class="separator:ga1f704e475da2aad1717e059c264c1436"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga9899534bc8eb78c227d895b396710091"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga9899534bc8eb78c227d895b396710091"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor7.html">bound_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga9899534bc8eb78c227d895b396710091">sigc::mem_fun7</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</td></tr>
+<tr class="memdesc:ga9899534bc8eb78c227d895b396710091"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor7.html" title="bound_mem_functor7 encapsulates a method with 7 arguments and an object instance.">sigc::bound_mem_functor7</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga9899534bc8eb78c227d895b396710091">More...</a><br /></td></tr>
+<tr class="separator:ga9899534bc8eb78c227d895b396710091"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga3d174b01bf94dbda3aea58c25c2b3322"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga3d174b01bf94dbda3aea58c25c2b3322"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor7.html">mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga3d174b01bf94dbda3aea58c25c2b3322">sigc::mem_fun7</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</td></tr>
+<tr class="memdesc:ga3d174b01bf94dbda3aea58c25c2b3322"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor7.html" title="mem_functor7 wraps methods with 7 argument(s).">sigc::mem_functor7</a> which wraps a method. <a href="group__mem__fun.html#ga3d174b01bf94dbda3aea58c25c2b3322">More...</a><br /></td></tr>
+<tr class="separator:ga3d174b01bf94dbda3aea58c25c2b3322"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<p><a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> Creates a functor from a pointer to a method. </p>
+<p>Optionally, a reference or pointer to an object can be bound to the functor.</p>
+<dl class="section note"><dt>Note</dt><dd>If the object type inherits from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>, and the functor returned from <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> is assigned to a <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a>, 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.</dd></dl>
+<p>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.</p>
+<dl class="section user"><dt>Example:</dt><dd><div class="fragment"><div class="line"><span class="keyword">struct </span>foo : <span class="keyword">public</span> <a class="code" href="structsigc_1_1trackable.html">sigc::trackable</a></div>
+<div class="line">{</div>
+<div class="line"> <span class="keywordtype">void</span> bar(<span class="keywordtype">int</span>) {}</div>
+<div class="line">};</div>
+<div class="line">foo my_foo;</div>
+<div class="line"><a class="code" href="classsigc_1_1slot.html">sigc::slot<void, int></a> sl = <a class="code" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">sigc::mem_fun</a>(my_foo, &foo::bar);</div>
+<div class="line"><span class="comment">// Note: f is not a slot. It will not be invalidated when my_foo is deleted.</span></div>
+<div class="line"><span class="keyword">auto</span> f = <a class="code" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">sigc::mem_fun</a>(my_foo, &foo::bar); <span class="comment">// Usually not what you want.</span></div>
+<div class="ttc" id="aclasssigc_1_1slot_html"><div class="ttname"><a href="classsigc_1_1slot.html">sigc::slot</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::slot# templates.</div><div class="ttdef"><b>Definition:</b> slot.h:1645</div></div>
+<div class="ttc" id="agroup__mem__fun_html_gadf6b6d22c503b439019f0a2e77352419"><div class="ttname"><a href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">sigc::mem_fun</a></div><div class="ttdeci">mem_functor0< T_return, T_obj > mem_fun(T_return(T_obj::*_A_func)())</div><div class="ttdoc">Creates a functor of type sigc::mem_functor0 which wraps a method.</div><div class="ttdef"><b>Definition:</b> mem_fun.h:5797</div></div>
+<div class="ttc" id="astructsigc_1_1trackable_html"><div class="ttname"><a href="structsigc_1_1trackable.html">sigc::trackable</a></div><div class="ttdoc">Base class for objects with auto-disconnection.</div><div class="ttdef"><b>Definition:</b> trackable.h:110</div></div>
+</div><!-- fragment --></dd></dl>
+<p>For const methods <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> takes a const reference or pointer to an object.</p>
+<dl class="section user"><dt>Example:</dt><dd><div class="fragment"><div class="line"><span class="keyword">struct </span>foo : <span class="keyword">public</span> <a class="code" href="structsigc_1_1trackable.html">sigc::trackable</a></div>
+<div class="line">{</div>
+<div class="line"> <span class="keywordtype">void</span> bar(<span class="keywordtype">int</span>)<span class="keyword"> const </span>{}</div>
+<div class="line">};</div>
+<div class="line"><span class="keyword">const</span> foo my_foo;</div>
+<div class="line"><a class="code" href="classsigc_1_1slot.html">sigc::slot<void, int></a> sl = <a class="code" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">sigc::mem_fun</a>(my_foo, &foo::bar);</div>
+</div><!-- fragment --></dd></dl>
+<p>Use mem_fun#() if there is an ambiguity as to the number of arguments.</p>
+<dl class="section user"><dt>Example:</dt><dd><div class="fragment"><div class="line"><span class="keyword">struct </span>foo : <span class="keyword">public</span> <a class="code" href="structsigc_1_1trackable.html">sigc::trackable</a></div>
+<div class="line">{</div>
+<div class="line"> <span class="keywordtype">void</span> bar(<span class="keywordtype">int</span>) {}</div>
+<div class="line"> <span class="keywordtype">void</span> bar(<span class="keywordtype">float</span>) {}</div>
+<div class="line"> <span class="keywordtype">void</span> bar(<span class="keywordtype">int</span>, <span class="keywordtype">int</span>) {}</div>
+<div class="line">};</div>
+<div class="line">foo my_foo;</div>
+<div class="line"><a class="code" href="classsigc_1_1slot.html">sigc::slot<void, int></a> sl = sigc::mem_fun1<int>(my_foo, &foo::bar);</div>
+</div><!-- fragment --> </dd></dl>
+<h2 class="groupheader">Function Documentation</h2>
+<a id="gaeef6e55681664df29b31edec51ea034d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaeef6e55681664df29b31edec51ea034d">◆ </a></span>mem_fun() <span class="overload">[1/24]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor0.html">bound_mem_functor0</a><T_return, T_obj> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)() </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor0.html" title="bound_mem_functor0 encapsulates a method with 0 arguments and an object instance.">sigc::bound_mem_functor0</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga7de39a04dfc6d37b2d12a25cdccfbe95"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga7de39a04dfc6d37b2d12a25cdccfbe95">◆ </a></span>mem_fun() <span class="overload">[2/24]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor1.html">bound_mem_functor1</a><T_return, T_obj, T_arg1> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1) </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor1.html" title="bound_mem_functor1 encapsulates a method with 1 arguments and an object instance.">sigc::bound_mem_functor1</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gab1add5c927b51b935b4f2d40558079fa"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gab1add5c927b51b935b4f2d40558079fa">◆ </a></span>mem_fun() <span class="overload">[3/24]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor2.html">bound_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2) </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor2.html" title="bound_mem_functor2 encapsulates a method with 2 arguments and an object instance.">sigc::bound_mem_functor2</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga1f1aa3b60c0d2d8b2470bba0b2b36023"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga1f1aa3b60c0d2d8b2470bba0b2b36023">◆ </a></span>mem_fun() <span class="overload">[4/24]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor3.html">bound_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3) </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor3.html" title="bound_mem_functor3 encapsulates a method with 3 arguments and an object instance.">sigc::bound_mem_functor3</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga481ef34d8423d26e8ff0a1916cd295d5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga481ef34d8423d26e8ff0a1916cd295d5">◆ </a></span>mem_fun() <span class="overload">[5/24]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor4.html">bound_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4) </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor4.html" title="bound_mem_functor4 encapsulates a method with 4 arguments and an object instance.">sigc::bound_mem_functor4</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga09fb13b1684ec7c092ffef695dbb261a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga09fb13b1684ec7c092ffef695dbb261a">◆ </a></span>mem_fun() <span class="overload">[6/24]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor5.html">bound_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor5.html" title="bound_mem_functor5 encapsulates a method with 5 arguments and an object instance.">sigc::bound_mem_functor5</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga0d9b992d69123a524b6c70c458ad0d40"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga0d9b992d69123a524b6c70c458ad0d40">◆ </a></span>mem_fun() <span class="overload">[7/24]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor6.html">bound_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor6.html" title="bound_mem_functor6 encapsulates a method with 6 arguments and an object instance.">sigc::bound_mem_functor6</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga5dcdaf235baa50049e6088d246853037"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga5dcdaf235baa50049e6088d246853037">◆ </a></span>mem_fun() <span class="overload">[8/24]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor7.html">bound_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor7.html" title="bound_mem_functor7 encapsulates a method with 7 arguments and an object instance.">sigc::bound_mem_functor7</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga7f57ec0156d33b4aa98e259d2e2062db"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga7f57ec0156d33b4aa98e259d2e2062db">◆ </a></span>mem_fun() <span class="overload">[9/24]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor0.html">bound_mem_functor0</a><T_return, T_obj> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)() </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor0.html" title="bound_mem_functor0 encapsulates a method with 0 arguments and an object instance.">sigc::bound_mem_functor0</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000098">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga0df7af9f32990cc624c4bb60782b4f78"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga0df7af9f32990cc624c4bb60782b4f78">◆ </a></span>mem_fun() <span class="overload">[10/24]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor1.html">bound_mem_functor1</a><T_return, T_obj, T_arg1> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1) </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor1.html" title="bound_mem_functor1 encapsulates a method with 1 arguments and an object instance.">sigc::bound_mem_functor1</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000099">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga118b2610268701be95cdc6fddb7bab3b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga118b2610268701be95cdc6fddb7bab3b">◆ </a></span>mem_fun() <span class="overload">[11/24]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor2.html">bound_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2) </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor2.html" title="bound_mem_functor2 encapsulates a method with 2 arguments and an object instance.">sigc::bound_mem_functor2</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000100">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaeb6bd4518e0f0c524dba13a6cbb2e319"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaeb6bd4518e0f0c524dba13a6cbb2e319">◆ </a></span>mem_fun() <span class="overload">[12/24]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor3.html">bound_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3) </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor3.html" title="bound_mem_functor3 encapsulates a method with 3 arguments and an object instance.">sigc::bound_mem_functor3</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000101">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga02c906c95895c58e39ee301bb1577994"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga02c906c95895c58e39ee301bb1577994">◆ </a></span>mem_fun() <span class="overload">[13/24]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor4.html">bound_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4) </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor4.html" title="bound_mem_functor4 encapsulates a method with 4 arguments and an object instance.">sigc::bound_mem_functor4</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000102">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gab138ae1a340be983166b69872826b37d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gab138ae1a340be983166b69872826b37d">◆ </a></span>mem_fun() <span class="overload">[14/24]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor5.html">bound_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor5.html" title="bound_mem_functor5 encapsulates a method with 5 arguments and an object instance.">sigc::bound_mem_functor5</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000103">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga3e3841c4844715d2f2d832ed506f028f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga3e3841c4844715d2f2d832ed506f028f">◆ </a></span>mem_fun() <span class="overload">[15/24]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor6.html">bound_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor6.html" title="bound_mem_functor6 encapsulates a method with 6 arguments and an object instance.">sigc::bound_mem_functor6</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000104">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaea5a2ace2699b8d1ffe93585e335548d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaea5a2ace2699b8d1ffe93585e335548d">◆ </a></span>mem_fun() <span class="overload">[16/24]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor7.html">bound_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor7.html" title="bound_mem_functor7 encapsulates a method with 7 arguments and an object instance.">sigc::bound_mem_functor7</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000105">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gadf6b6d22c503b439019f0a2e77352419"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gadf6b6d22c503b439019f0a2e77352419">◆ </a></span>mem_fun() <span class="overload">[17/24]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor0.html">mem_functor0</a><T_return, T_obj> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)() </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1mem__functor0.html" title="mem_functor0 wraps methods with 0 argument(s).">sigc::mem_functor0</a> which wraps a method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gab661fef0f04e2e439912eee6989e9657"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gab661fef0f04e2e439912eee6989e9657">◆ </a></span>mem_fun() <span class="overload">[18/24]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor1.html">mem_functor1</a><T_return, T_obj, T_arg1> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1) </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1mem__functor1.html" title="mem_functor1 wraps methods with 1 argument(s).">sigc::mem_functor1</a> which wraps a method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5">◆ </a></span>mem_fun() <span class="overload">[19/24]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor2.html">mem_functor2</a><T_return, T_obj, T_arg1, T_arg2> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2) </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1mem__functor2.html" title="mem_functor2 wraps methods with 2 argument(s).">sigc::mem_functor2</a> which wraps a method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaa3778234963fa65d4f638856d91109d1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaa3778234963fa65d4f638856d91109d1">◆ </a></span>mem_fun() <span class="overload">[20/24]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor3.html">mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3) </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1mem__functor3.html" title="mem_functor3 wraps methods with 3 argument(s).">sigc::mem_functor3</a> which wraps a method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gadadd40aba6dadd0edbaac609dfae3938"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gadadd40aba6dadd0edbaac609dfae3938">◆ </a></span>mem_fun() <span class="overload">[21/24]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor4.html">mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4) </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1mem__functor4.html" title="mem_functor4 wraps methods with 4 argument(s).">sigc::mem_functor4</a> which wraps a method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaa01df6c622d59cfd2d0d8aa3c04c36d1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaa01df6c622d59cfd2d0d8aa3c04c36d1">◆ </a></span>mem_fun() <span class="overload">[22/24]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor5.html">mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1mem__functor5.html" title="mem_functor5 wraps methods with 5 argument(s).">sigc::mem_functor5</a> which wraps a method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga9030b647c35e06c68342fee34e8fd320"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga9030b647c35e06c68342fee34e8fd320">◆ </a></span>mem_fun() <span class="overload">[23/24]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor6.html">mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1mem__functor6.html" title="mem_functor6 wraps methods with 6 argument(s).">sigc::mem_functor6</a> which wraps a method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga54e4bf947e8c93c56931b8e8f7ed0d2e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga54e4bf947e8c93c56931b8e8f7ed0d2e">◆ </a></span>mem_fun() <span class="overload">[24/24]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor7.html">mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1mem__functor7.html" title="mem_functor7 wraps methods with 7 argument(s).">sigc::mem_functor7</a> which wraps a method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaf71277763f14050e2d270fcf3ea41dc9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaf71277763f14050e2d270fcf3ea41dc9">◆ </a></span>mem_fun0() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor0.html">bound_mem_functor0</a><T_return, T_obj> sigc::mem_fun0 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)() </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor0.html" title="bound_mem_functor0 encapsulates a method with 0 arguments and an object instance.">sigc::bound_mem_functor0</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gae03d0b73b85e85d2ad8bc43b19b855e3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gae03d0b73b85e85d2ad8bc43b19b855e3">◆ </a></span>mem_fun0() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor0.html">bound_mem_functor0</a><T_return, T_obj> sigc::mem_fun0 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)() </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor0.html" title="bound_mem_functor0 encapsulates a method with 0 arguments and an object instance.">sigc::bound_mem_functor0</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000066">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga765b35689a909fbc2a627be8256c5b1f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga765b35689a909fbc2a627be8256c5b1f">◆ </a></span>mem_fun0() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor0.html">mem_functor0</a><T_return, T_obj> sigc::mem_fun0 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)() </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1mem__functor0.html" title="mem_functor0 wraps methods with 0 argument(s).">sigc::mem_functor0</a> which wraps a method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaade596a4dacfd1429039525bb9f399d0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaade596a4dacfd1429039525bb9f399d0">◆ </a></span>mem_fun1() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor1.html">bound_mem_functor1</a><T_return, T_obj, T_arg1> sigc::mem_fun1 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1) </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor1.html" title="bound_mem_functor1 encapsulates a method with 1 arguments and an object instance.">sigc::bound_mem_functor1</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga3dd8d2ed97310dbf4fa394999f0be7b7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga3dd8d2ed97310dbf4fa394999f0be7b7">◆ </a></span>mem_fun1() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor1.html">bound_mem_functor1</a><T_return, T_obj, T_arg1> sigc::mem_fun1 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1) </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor1.html" title="bound_mem_functor1 encapsulates a method with 1 arguments and an object instance.">sigc::bound_mem_functor1</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000067">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gae0bebf0d8a2d36d93746c23d9eea668d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gae0bebf0d8a2d36d93746c23d9eea668d">◆ </a></span>mem_fun1() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor1.html">mem_functor1</a><T_return, T_obj, T_arg1> sigc::mem_fun1 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1) </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1mem__functor1.html" title="mem_functor1 wraps methods with 1 argument(s).">sigc::mem_functor1</a> which wraps a method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaee7652f1a0625df50af50e28b5e2423e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaee7652f1a0625df50af50e28b5e2423e">◆ </a></span>mem_fun2() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor2.html">bound_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2> sigc::mem_fun2 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2) </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor2.html" title="bound_mem_functor2 encapsulates a method with 2 arguments and an object instance.">sigc::bound_mem_functor2</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga184da4166c8b5409dc4b98d7bc16dff8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga184da4166c8b5409dc4b98d7bc16dff8">◆ </a></span>mem_fun2() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor2.html">bound_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2> sigc::mem_fun2 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2) </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor2.html" title="bound_mem_functor2 encapsulates a method with 2 arguments and an object instance.">sigc::bound_mem_functor2</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000068">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gab76f41aeada332b353b6fe2e96008831"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gab76f41aeada332b353b6fe2e96008831">◆ </a></span>mem_fun2() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor2.html">mem_functor2</a><T_return, T_obj, T_arg1, T_arg2> sigc::mem_fun2 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2) </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1mem__functor2.html" title="mem_functor2 wraps methods with 2 argument(s).">sigc::mem_functor2</a> which wraps a method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga14e07df139b5cb6897e671c50fc33cde"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga14e07df139b5cb6897e671c50fc33cde">◆ </a></span>mem_fun3() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor3.html">bound_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3> sigc::mem_fun3 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3) </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor3.html" title="bound_mem_functor3 encapsulates a method with 3 arguments and an object instance.">sigc::bound_mem_functor3</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga4f2fdbf02e8cac9492326a4a8ffdd012"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga4f2fdbf02e8cac9492326a4a8ffdd012">◆ </a></span>mem_fun3() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor3.html">bound_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3> sigc::mem_fun3 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3) </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor3.html" title="bound_mem_functor3 encapsulates a method with 3 arguments and an object instance.">sigc::bound_mem_functor3</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000069">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga2379e0d689fe4a99c7c669fc29817457"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga2379e0d689fe4a99c7c669fc29817457">◆ </a></span>mem_fun3() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor3.html">mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3> sigc::mem_fun3 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3) </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1mem__functor3.html" title="mem_functor3 wraps methods with 3 argument(s).">sigc::mem_functor3</a> which wraps a method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga86da5637e2735480d525ffa930e7e21a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga86da5637e2735480d525ffa930e7e21a">◆ </a></span>mem_fun4() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor4.html">bound_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> sigc::mem_fun4 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4) </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor4.html" title="bound_mem_functor4 encapsulates a method with 4 arguments and an object instance.">sigc::bound_mem_functor4</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga94a2525ef116e16598b81b853544a170"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga94a2525ef116e16598b81b853544a170">◆ </a></span>mem_fun4() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor4.html">bound_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> sigc::mem_fun4 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4) </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor4.html" title="bound_mem_functor4 encapsulates a method with 4 arguments and an object instance.">sigc::bound_mem_functor4</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000070">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga1bedd04f76ad3e21f614912562e95d83"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga1bedd04f76ad3e21f614912562e95d83">◆ </a></span>mem_fun4() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor4.html">mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> sigc::mem_fun4 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4) </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1mem__functor4.html" title="mem_functor4 wraps methods with 4 argument(s).">sigc::mem_functor4</a> which wraps a method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga5c2ca9cef8c857935a59133a73ef61f2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga5c2ca9cef8c857935a59133a73ef61f2">◆ </a></span>mem_fun5() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor5.html">bound_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> sigc::mem_fun5 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor5.html" title="bound_mem_functor5 encapsulates a method with 5 arguments and an object instance.">sigc::bound_mem_functor5</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaf060fe3a2be4ff7c0f50aef54b4dc8bf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaf060fe3a2be4ff7c0f50aef54b4dc8bf">◆ </a></span>mem_fun5() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor5.html">bound_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> sigc::mem_fun5 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor5.html" title="bound_mem_functor5 encapsulates a method with 5 arguments and an object instance.">sigc::bound_mem_functor5</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000071">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga3ef4bb904a751d29e2b6803ef81f72fa"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga3ef4bb904a751d29e2b6803ef81f72fa">◆ </a></span>mem_fun5() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor5.html">mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> sigc::mem_fun5 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1mem__functor5.html" title="mem_functor5 wraps methods with 5 argument(s).">sigc::mem_functor5</a> which wraps a method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga947f4410e62a2996023177e490c882b7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga947f4410e62a2996023177e490c882b7">◆ </a></span>mem_fun6() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor6.html">bound_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> sigc::mem_fun6 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor6.html" title="bound_mem_functor6 encapsulates a method with 6 arguments and an object instance.">sigc::bound_mem_functor6</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gac0a6242da9bf96642f25c1363dfef383"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gac0a6242da9bf96642f25c1363dfef383">◆ </a></span>mem_fun6() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor6.html">bound_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> sigc::mem_fun6 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor6.html" title="bound_mem_functor6 encapsulates a method with 6 arguments and an object instance.">sigc::bound_mem_functor6</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000072">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga34ace98fbbd18cb635795639d0f22678"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga34ace98fbbd18cb635795639d0f22678">◆ </a></span>mem_fun6() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor6.html">mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> sigc::mem_fun6 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1mem__functor6.html" title="mem_functor6 wraps methods with 6 argument(s).">sigc::mem_functor6</a> which wraps a method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga1f704e475da2aad1717e059c264c1436"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga1f704e475da2aad1717e059c264c1436">◆ </a></span>mem_fun7() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor7.html">bound_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sigc::mem_fun7 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor7.html" title="bound_mem_functor7 encapsulates a method with 7 arguments and an object instance.">sigc::bound_mem_functor7</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga9899534bc8eb78c227d895b396710091"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga9899534bc8eb78c227d895b396710091">◆ </a></span>mem_fun7() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__mem__functor7.html">bound_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sigc::mem_fun7 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor7.html" title="bound_mem_functor7 encapsulates a method with 7 arguments and an object instance.">sigc::bound_mem_functor7</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000073">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga3d174b01bf94dbda3aea58c25c2b3322"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga3d174b01bf94dbda3aea58c25c2b3322">◆ </a></span>mem_fun7() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1mem__functor7.html">mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sigc::mem_fun7 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1mem__functor7.html" title="mem_functor7 wraps methods with 7 argument(s).">sigc::mem_functor7</a> which wraps a method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: ptr_fun()</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#nested-classes">Classes</a> |
+<a href="#func-members">Functions</a> </div>
+ <div class="headertitle">
+<div class="title">ptr_fun()<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863" title="Creates a functor of type sigc::pointer_functor0 which wraps an existing non-member function.">ptr_fun()</a> is used to convert a pointer to a function to a functor.
+<a href="#details">More...</a></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Classes</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor0.html">sigc::pointer_functor0< T_return ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1pointer__functor0.html" title="pointer_functor0 wraps existing non-member functions with 0 argument(s).">pointer_functor0</a> wraps existing non-member functions with 0 argument(s). <a href="classsigc_1_1pointer__functor0.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor1.html">sigc::pointer_functor1< T_arg1, T_return ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1pointer__functor1.html" title="pointer_functor1 wraps existing non-member functions with 1 argument(s).">pointer_functor1</a> wraps existing non-member functions with 1 argument(s). <a href="classsigc_1_1pointer__functor1.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor2.html">sigc::pointer_functor2< T_arg1, T_arg2, T_return ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1pointer__functor2.html" title="pointer_functor2 wraps existing non-member functions with 2 argument(s).">pointer_functor2</a> wraps existing non-member functions with 2 argument(s). <a href="classsigc_1_1pointer__functor2.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor3.html">sigc::pointer_functor3< T_arg1, T_arg2, T_arg3, T_return ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1pointer__functor3.html" title="pointer_functor3 wraps existing non-member functions with 3 argument(s).">pointer_functor3</a> wraps existing non-member functions with 3 argument(s). <a href="classsigc_1_1pointer__functor3.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor4.html">sigc::pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1pointer__functor4.html" title="pointer_functor4 wraps existing non-member functions with 4 argument(s).">pointer_functor4</a> wraps existing non-member functions with 4 argument(s). <a href="classsigc_1_1pointer__functor4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor5.html">sigc::pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1pointer__functor5.html" title="pointer_functor5 wraps existing non-member functions with 5 argument(s).">pointer_functor5</a> wraps existing non-member functions with 5 argument(s). <a href="classsigc_1_1pointer__functor5.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor6.html">sigc::pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1pointer__functor6.html" title="pointer_functor6 wraps existing non-member functions with 6 argument(s).">pointer_functor6</a> wraps existing non-member functions with 6 argument(s). <a href="classsigc_1_1pointer__functor6.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor7.html">sigc::pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1pointer__functor7.html" title="pointer_functor7 wraps existing non-member functions with 7 argument(s).">pointer_functor7</a> wraps existing non-member functions with 7 argument(s). <a href="classsigc_1_1pointer__functor7.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
+Functions</h2></td></tr>
+<tr class="memitem:ga9c80de72f656fb05e81fda622dddc863"><td class="memTemplParams" colspan="2">template<class T_return > </td></tr>
+<tr class="memitem:ga9c80de72f656fb05e81fda622dddc863"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor0.html">pointer_functor0</a>< T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863">sigc::ptr_fun</a> (T_return(* _A_func)())</td></tr>
+<tr class="memdesc:ga9c80de72f656fb05e81fda622dddc863"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor0.html" title="pointer_functor0 wraps existing non-member functions with 0 argument(s).">sigc::pointer_functor0</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863">More...</a><br /></td></tr>
+<tr class="separator:ga9c80de72f656fb05e81fda622dddc863"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga9b1c3b4ecb24056f5bd38fc6a87f9ad1"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return > </td></tr>
+<tr class="memitem:ga9b1c3b4ecb24056f5bd38fc6a87f9ad1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor1.html">pointer_functor1</a>< T_arg1, T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#ga9b1c3b4ecb24056f5bd38fc6a87f9ad1">sigc::ptr_fun</a> (T_return(* _A_func)(T_arg1))</td></tr>
+<tr class="memdesc:ga9b1c3b4ecb24056f5bd38fc6a87f9ad1"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor1.html" title="pointer_functor1 wraps existing non-member functions with 1 argument(s).">sigc::pointer_functor1</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#ga9b1c3b4ecb24056f5bd38fc6a87f9ad1">More...</a><br /></td></tr>
+<tr class="separator:ga9b1c3b4ecb24056f5bd38fc6a87f9ad1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga9c0db14ab1a864b2bad70000325d94c8"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return > </td></tr>
+<tr class="memitem:ga9c0db14ab1a864b2bad70000325d94c8"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor2.html">pointer_functor2</a>< T_arg1, T_arg2, T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#ga9c0db14ab1a864b2bad70000325d94c8">sigc::ptr_fun</a> (T_return(* _A_func)(T_arg1, T_arg2))</td></tr>
+<tr class="memdesc:ga9c0db14ab1a864b2bad70000325d94c8"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor2.html" title="pointer_functor2 wraps existing non-member functions with 2 argument(s).">sigc::pointer_functor2</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#ga9c0db14ab1a864b2bad70000325d94c8">More...</a><br /></td></tr>
+<tr class="separator:ga9c0db14ab1a864b2bad70000325d94c8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga1cd2254135f3afcfc5ce34e73cf2f48b"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return > </td></tr>
+<tr class="memitem:ga1cd2254135f3afcfc5ce34e73cf2f48b"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor3.html">pointer_functor3</a>< T_arg1, T_arg2, T_arg3, T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#ga1cd2254135f3afcfc5ce34e73cf2f48b">sigc::ptr_fun</a> (T_return(* _A_func)(T_arg1, T_arg2, T_arg3))</td></tr>
+<tr class="memdesc:ga1cd2254135f3afcfc5ce34e73cf2f48b"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor3.html" title="pointer_functor3 wraps existing non-member functions with 3 argument(s).">sigc::pointer_functor3</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#ga1cd2254135f3afcfc5ce34e73cf2f48b">More...</a><br /></td></tr>
+<tr class="separator:ga1cd2254135f3afcfc5ce34e73cf2f48b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaa23ae1abf223560bcac001b86d3cc484"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return > </td></tr>
+<tr class="memitem:gaa23ae1abf223560bcac001b86d3cc484"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor4.html">pointer_functor4</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#gaa23ae1abf223560bcac001b86d3cc484">sigc::ptr_fun</a> (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</td></tr>
+<tr class="memdesc:gaa23ae1abf223560bcac001b86d3cc484"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor4.html" title="pointer_functor4 wraps existing non-member functions with 4 argument(s).">sigc::pointer_functor4</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#gaa23ae1abf223560bcac001b86d3cc484">More...</a><br /></td></tr>
+<tr class="separator:gaa23ae1abf223560bcac001b86d3cc484"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gafd3087df10b981325953c93e914d451e"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return > </td></tr>
+<tr class="memitem:gafd3087df10b981325953c93e914d451e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor5.html">pointer_functor5</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#gafd3087df10b981325953c93e914d451e">sigc::ptr_fun</a> (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</td></tr>
+<tr class="memdesc:gafd3087df10b981325953c93e914d451e"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor5.html" title="pointer_functor5 wraps existing non-member functions with 5 argument(s).">sigc::pointer_functor5</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#gafd3087df10b981325953c93e914d451e">More...</a><br /></td></tr>
+<tr class="separator:gafd3087df10b981325953c93e914d451e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga0f4d43c3aace56cc5ce0f38886b9ace6"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return > </td></tr>
+<tr class="memitem:ga0f4d43c3aace56cc5ce0f38886b9ace6"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor6.html">pointer_functor6</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#ga0f4d43c3aace56cc5ce0f38886b9ace6">sigc::ptr_fun</a> (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</td></tr>
+<tr class="memdesc:ga0f4d43c3aace56cc5ce0f38886b9ace6"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor6.html" title="pointer_functor6 wraps existing non-member functions with 6 argument(s).">sigc::pointer_functor6</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#ga0f4d43c3aace56cc5ce0f38886b9ace6">More...</a><br /></td></tr>
+<tr class="separator:ga0f4d43c3aace56cc5ce0f38886b9ace6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga65221432dda1b020b73349627762da70"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return > </td></tr>
+<tr class="memitem:ga65221432dda1b020b73349627762da70"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor7.html">pointer_functor7</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#ga65221432dda1b020b73349627762da70">sigc::ptr_fun</a> (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</td></tr>
+<tr class="memdesc:ga65221432dda1b020b73349627762da70"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor7.html" title="pointer_functor7 wraps existing non-member functions with 7 argument(s).">sigc::pointer_functor7</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#ga65221432dda1b020b73349627762da70">More...</a><br /></td></tr>
+<tr class="separator:ga65221432dda1b020b73349627762da70"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaad8dffc194a4e4dfa0935ce49d43cd5c"><td class="memTemplParams" colspan="2">template<class T_return > </td></tr>
+<tr class="memitem:gaad8dffc194a4e4dfa0935ce49d43cd5c"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor0.html">pointer_functor0</a>< T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#gaad8dffc194a4e4dfa0935ce49d43cd5c">sigc::ptr_fun0</a> (T_return(* _A_func)())</td></tr>
+<tr class="memdesc:gaad8dffc194a4e4dfa0935ce49d43cd5c"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor0.html" title="pointer_functor0 wraps existing non-member functions with 0 argument(s).">sigc::pointer_functor0</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#gaad8dffc194a4e4dfa0935ce49d43cd5c">More...</a><br /></td></tr>
+<tr class="separator:gaad8dffc194a4e4dfa0935ce49d43cd5c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga9b1b8e8f5555d6be4ba41be3fb82c94e"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return > </td></tr>
+<tr class="memitem:ga9b1b8e8f5555d6be4ba41be3fb82c94e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor1.html">pointer_functor1</a>< T_arg1, T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#ga9b1b8e8f5555d6be4ba41be3fb82c94e">sigc::ptr_fun1</a> (T_return(* _A_func)(T_arg1))</td></tr>
+<tr class="memdesc:ga9b1b8e8f5555d6be4ba41be3fb82c94e"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor1.html" title="pointer_functor1 wraps existing non-member functions with 1 argument(s).">sigc::pointer_functor1</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#ga9b1b8e8f5555d6be4ba41be3fb82c94e">More...</a><br /></td></tr>
+<tr class="separator:ga9b1b8e8f5555d6be4ba41be3fb82c94e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga0244165b83e41a30b2dfb9523afad446"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return > </td></tr>
+<tr class="memitem:ga0244165b83e41a30b2dfb9523afad446"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor2.html">pointer_functor2</a>< T_arg1, T_arg2, T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#ga0244165b83e41a30b2dfb9523afad446">sigc::ptr_fun2</a> (T_return(* _A_func)(T_arg1, T_arg2))</td></tr>
+<tr class="memdesc:ga0244165b83e41a30b2dfb9523afad446"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor2.html" title="pointer_functor2 wraps existing non-member functions with 2 argument(s).">sigc::pointer_functor2</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#ga0244165b83e41a30b2dfb9523afad446">More...</a><br /></td></tr>
+<tr class="separator:ga0244165b83e41a30b2dfb9523afad446"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga749e83ea85926d5ad6994d775f98de8d"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return > </td></tr>
+<tr class="memitem:ga749e83ea85926d5ad6994d775f98de8d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor3.html">pointer_functor3</a>< T_arg1, T_arg2, T_arg3, T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#ga749e83ea85926d5ad6994d775f98de8d">sigc::ptr_fun3</a> (T_return(* _A_func)(T_arg1, T_arg2, T_arg3))</td></tr>
+<tr class="memdesc:ga749e83ea85926d5ad6994d775f98de8d"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor3.html" title="pointer_functor3 wraps existing non-member functions with 3 argument(s).">sigc::pointer_functor3</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#ga749e83ea85926d5ad6994d775f98de8d">More...</a><br /></td></tr>
+<tr class="separator:ga749e83ea85926d5ad6994d775f98de8d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gac6fa01189c786e778d943a2ee60896a4"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return > </td></tr>
+<tr class="memitem:gac6fa01189c786e778d943a2ee60896a4"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor4.html">pointer_functor4</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#gac6fa01189c786e778d943a2ee60896a4">sigc::ptr_fun4</a> (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</td></tr>
+<tr class="memdesc:gac6fa01189c786e778d943a2ee60896a4"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor4.html" title="pointer_functor4 wraps existing non-member functions with 4 argument(s).">sigc::pointer_functor4</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#gac6fa01189c786e778d943a2ee60896a4">More...</a><br /></td></tr>
+<tr class="separator:gac6fa01189c786e778d943a2ee60896a4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga37ae059caefef68e441d3dd7d5b11cce"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return > </td></tr>
+<tr class="memitem:ga37ae059caefef68e441d3dd7d5b11cce"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor5.html">pointer_functor5</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#ga37ae059caefef68e441d3dd7d5b11cce">sigc::ptr_fun5</a> (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</td></tr>
+<tr class="memdesc:ga37ae059caefef68e441d3dd7d5b11cce"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor5.html" title="pointer_functor5 wraps existing non-member functions with 5 argument(s).">sigc::pointer_functor5</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#ga37ae059caefef68e441d3dd7d5b11cce">More...</a><br /></td></tr>
+<tr class="separator:ga37ae059caefef68e441d3dd7d5b11cce"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga8cdf17b7ec15b260f5147e1171dd5299"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return > </td></tr>
+<tr class="memitem:ga8cdf17b7ec15b260f5147e1171dd5299"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor6.html">pointer_functor6</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#ga8cdf17b7ec15b260f5147e1171dd5299">sigc::ptr_fun6</a> (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</td></tr>
+<tr class="memdesc:ga8cdf17b7ec15b260f5147e1171dd5299"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor6.html" title="pointer_functor6 wraps existing non-member functions with 6 argument(s).">sigc::pointer_functor6</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#ga8cdf17b7ec15b260f5147e1171dd5299">More...</a><br /></td></tr>
+<tr class="separator:ga8cdf17b7ec15b260f5147e1171dd5299"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga82e53ab558dae814c16a09edb53617bb"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return > </td></tr>
+<tr class="memitem:ga82e53ab558dae814c16a09edb53617bb"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor7.html">pointer_functor7</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#ga82e53ab558dae814c16a09edb53617bb">sigc::ptr_fun7</a> (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</td></tr>
+<tr class="memdesc:ga82e53ab558dae814c16a09edb53617bb"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor7.html" title="pointer_functor7 wraps existing non-member functions with 7 argument(s).">sigc::pointer_functor7</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#ga82e53ab558dae814c16a09edb53617bb">More...</a><br /></td></tr>
+<tr class="separator:ga82e53ab558dae814c16a09edb53617bb"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<p><a class="el" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863" title="Creates a functor of type sigc::pointer_functor0 which wraps an existing non-member function.">ptr_fun()</a> is used to convert a pointer to a function to a functor. </p>
+<p>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.</p>
+<dl class="section user"><dt>Example:</dt><dd><div class="fragment"><div class="line"><span class="keywordtype">void</span> foo(<span class="keywordtype">int</span>) {}</div>
+<div class="line"><a class="code" href="classsigc_1_1slot.html">sigc::slot<void, int></a> sl = <a class="code" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863">sigc::ptr_fun</a>(&foo);</div>
+<div class="ttc" id="aclasssigc_1_1slot_html"><div class="ttname"><a href="classsigc_1_1slot.html">sigc::slot</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::slot# templates.</div><div class="ttdef"><b>Definition:</b> slot.h:1645</div></div>
+<div class="ttc" id="agroup__ptr__fun_html_ga9c80de72f656fb05e81fda622dddc863"><div class="ttname"><a href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863">sigc::ptr_fun</a></div><div class="ttdeci">pointer_functor0< T_return > ptr_fun(T_return(*_A_func)())</div><div class="ttdoc">Creates a functor of type sigc::pointer_functor0 which wraps an existing non-member function.</div><div class="ttdef"><b>Definition:</b> ptr_fun.h:460</div></div>
+</div><!-- fragment --></dd></dl>
+<p>Use ptr_fun#() if there is an ambiguity as to the number of arguments.</p>
+<dl class="section user"><dt>Example:</dt><dd><div class="fragment"><div class="line"><span class="keywordtype">void</span> foo(<span class="keywordtype">int</span>) {} <span class="comment">// choose this one</span></div>
+<div class="line"><span class="keywordtype">void</span> foo(<span class="keywordtype">float</span>) {}</div>
+<div class="line"><span class="keywordtype">void</span> foo(<span class="keywordtype">int</span>, <span class="keywordtype">int</span>) {}</div>
+<div class="line"><a class="code" href="classsigc_1_1slot.html">sigc::slot<void, long></a> sl = sigc::ptr_fun1<int>(&foo);</div>
+</div><!-- fragment --></dd></dl>
+<p><a class="el" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863" title="Creates a functor of type sigc::pointer_functor0 which wraps an existing non-member function.">ptr_fun()</a> can also be used to convert a pointer to a static member function to a functor, like so:</p>
+<dl class="section user"><dt>Example:</dt><dd><div class="fragment"><div class="line"><span class="keyword">struct </span>foo</div>
+<div class="line">{</div>
+<div class="line"> <span class="keyword">static</span> <span class="keywordtype">void</span> bar(<span class="keywordtype">int</span>) {}</div>
+<div class="line">};</div>
+<div class="line"><a class="code" href="classsigc_1_1slot.html">sigc::slot<void, int></a> sl = <a class="code" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863">sigc::ptr_fun</a>(&foo::bar);</div>
+</div><!-- fragment --> </dd></dl>
+<h2 class="groupheader">Function Documentation</h2>
+<a id="ga9c80de72f656fb05e81fda622dddc863"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga9c80de72f656fb05e81fda622dddc863">◆ </a></span>ptr_fun() <span class="overload">[1/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor0.html">pointer_functor0</a><T_return> sigc::ptr_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(*)() </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor0.html" title="pointer_functor0 wraps existing non-member functions with 0 argument(s).">sigc::pointer_functor0</a> which wraps an existing non-member function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to function that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga9b1c3b4ecb24056f5bd38fc6a87f9ad1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga9b1c3b4ecb24056f5bd38fc6a87f9ad1">◆ </a></span>ptr_fun() <span class="overload">[2/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor1.html">pointer_functor1</a><T_arg1, T_return> sigc::ptr_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(*)(T_arg1) </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor1.html" title="pointer_functor1 wraps existing non-member functions with 1 argument(s).">sigc::pointer_functor1</a> which wraps an existing non-member function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to function that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga9c0db14ab1a864b2bad70000325d94c8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga9c0db14ab1a864b2bad70000325d94c8">◆ </a></span>ptr_fun() <span class="overload">[3/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor2.html">pointer_functor2</a><T_arg1, T_arg2, T_return> sigc::ptr_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(*)(T_arg1, T_arg2) </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor2.html" title="pointer_functor2 wraps existing non-member functions with 2 argument(s).">sigc::pointer_functor2</a> which wraps an existing non-member function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to function that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga1cd2254135f3afcfc5ce34e73cf2f48b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga1cd2254135f3afcfc5ce34e73cf2f48b">◆ </a></span>ptr_fun() <span class="overload">[4/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor3.html">pointer_functor3</a><T_arg1, T_arg2, T_arg3, T_return> sigc::ptr_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(*)(T_arg1, T_arg2, T_arg3) </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor3.html" title="pointer_functor3 wraps existing non-member functions with 3 argument(s).">sigc::pointer_functor3</a> which wraps an existing non-member function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to function that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaa23ae1abf223560bcac001b86d3cc484"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaa23ae1abf223560bcac001b86d3cc484">◆ </a></span>ptr_fun() <span class="overload">[5/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor4.html">pointer_functor4</a><T_arg1, T_arg2, T_arg3, T_arg4, T_return> sigc::ptr_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(*)(T_arg1, T_arg2, T_arg3, T_arg4) </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor4.html" title="pointer_functor4 wraps existing non-member functions with 4 argument(s).">sigc::pointer_functor4</a> which wraps an existing non-member function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to function that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gafd3087df10b981325953c93e914d451e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gafd3087df10b981325953c93e914d451e">◆ </a></span>ptr_fun() <span class="overload">[6/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor5.html">pointer_functor5</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return> sigc::ptr_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor5.html" title="pointer_functor5 wraps existing non-member functions with 5 argument(s).">sigc::pointer_functor5</a> which wraps an existing non-member function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to function that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga0f4d43c3aace56cc5ce0f38886b9ace6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga0f4d43c3aace56cc5ce0f38886b9ace6">◆ </a></span>ptr_fun() <span class="overload">[7/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor6.html">pointer_functor6</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return> sigc::ptr_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor6.html" title="pointer_functor6 wraps existing non-member functions with 6 argument(s).">sigc::pointer_functor6</a> which wraps an existing non-member function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to function that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga65221432dda1b020b73349627762da70"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga65221432dda1b020b73349627762da70">◆ </a></span>ptr_fun() <span class="overload">[8/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor7.html">pointer_functor7</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return> sigc::ptr_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor7.html" title="pointer_functor7 wraps existing non-member functions with 7 argument(s).">sigc::pointer_functor7</a> which wraps an existing non-member function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to function that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaad8dffc194a4e4dfa0935ce49d43cd5c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaad8dffc194a4e4dfa0935ce49d43cd5c">◆ </a></span>ptr_fun0()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor0.html">pointer_functor0</a><T_return> sigc::ptr_fun0 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(*)() </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor0.html" title="pointer_functor0 wraps existing non-member functions with 0 argument(s).">sigc::pointer_functor0</a> which wraps an existing non-member function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to function that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga9b1b8e8f5555d6be4ba41be3fb82c94e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga9b1b8e8f5555d6be4ba41be3fb82c94e">◆ </a></span>ptr_fun1()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor1.html">pointer_functor1</a><T_arg1, T_return> sigc::ptr_fun1 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(*)(T_arg1) </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor1.html" title="pointer_functor1 wraps existing non-member functions with 1 argument(s).">sigc::pointer_functor1</a> which wraps an existing non-member function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to function that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga0244165b83e41a30b2dfb9523afad446"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga0244165b83e41a30b2dfb9523afad446">◆ </a></span>ptr_fun2()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor2.html">pointer_functor2</a><T_arg1, T_arg2, T_return> sigc::ptr_fun2 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(*)(T_arg1, T_arg2) </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor2.html" title="pointer_functor2 wraps existing non-member functions with 2 argument(s).">sigc::pointer_functor2</a> which wraps an existing non-member function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to function that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga749e83ea85926d5ad6994d775f98de8d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga749e83ea85926d5ad6994d775f98de8d">◆ </a></span>ptr_fun3()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor3.html">pointer_functor3</a><T_arg1, T_arg2, T_arg3, T_return> sigc::ptr_fun3 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(*)(T_arg1, T_arg2, T_arg3) </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor3.html" title="pointer_functor3 wraps existing non-member functions with 3 argument(s).">sigc::pointer_functor3</a> which wraps an existing non-member function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to function that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gac6fa01189c786e778d943a2ee60896a4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gac6fa01189c786e778d943a2ee60896a4">◆ </a></span>ptr_fun4()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor4.html">pointer_functor4</a><T_arg1, T_arg2, T_arg3, T_arg4, T_return> sigc::ptr_fun4 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(*)(T_arg1, T_arg2, T_arg3, T_arg4) </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor4.html" title="pointer_functor4 wraps existing non-member functions with 4 argument(s).">sigc::pointer_functor4</a> which wraps an existing non-member function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to function that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga37ae059caefef68e441d3dd7d5b11cce"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga37ae059caefef68e441d3dd7d5b11cce">◆ </a></span>ptr_fun5()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor5.html">pointer_functor5</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return> sigc::ptr_fun5 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor5.html" title="pointer_functor5 wraps existing non-member functions with 5 argument(s).">sigc::pointer_functor5</a> which wraps an existing non-member function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to function that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga8cdf17b7ec15b260f5147e1171dd5299"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga8cdf17b7ec15b260f5147e1171dd5299">◆ </a></span>ptr_fun6()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor6.html">pointer_functor6</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return> sigc::ptr_fun6 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor6.html" title="pointer_functor6 wraps existing non-member functions with 6 argument(s).">sigc::pointer_functor6</a> which wraps an existing non-member function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to function that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga82e53ab558dae814c16a09edb53617bb"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga82e53ab558dae814c16a09edb53617bb">◆ </a></span>ptr_fun7()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1pointer__functor7.html">pointer_functor7</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return> sigc::ptr_fun7 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor7.html" title="pointer_functor7 wraps existing non-member functions with 7 argument(s).">sigc::pointer_functor7</a> which wraps an existing non-member function. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to function that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: retype(), retype_return()</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#nested-classes">Classes</a> |
+<a href="#func-members">Functions</a> </div>
+ <div class="headertitle">
+<div class="title">retype(), retype_return()<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="group__retype.html#ga8b98eeb2a61b5b1f84dcd1d20fe666f1" title="Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed...">sigc::retype()</a> alters a sigc::pointer_functor, a sigc::mem_functor or a <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> in that it makes C-style casts to the functor's parameter types of all parameters passed through operator()().
+<a href="#details">More...</a></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Classes</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__functor.html">sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that performs C-style casts on the parameters passed on to the functor. <a href="structsigc_1_1retype__functor.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor< T_return, T_functor ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that performs a C-style cast on the return value of a functor. <a href="structsigc_1_1retype__return__functor.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html">sigc::retype_return_functor< void, T_functor ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that performs a C-style cast on the return value of a functor. <a href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
+Functions</h2></td></tr>
+<tr class="memitem:ga31061f134d93297fd0b4f2d56efafbe3"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga31061f134d93297fd0b4f2d56efafbe3"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__mem__functor0.html">bound_const_mem_functor0</a>< T_return, T_obj > > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga31061f134d93297fd0b4f2d56efafbe3">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__const__mem__functor0.html">bound_const_mem_functor0</a>< T_return, T_obj > & _A_functor)</td></tr>
+<tr class="memdesc:ga31061f134d93297fd0b4f2d56efafbe3"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga31061f134d93297fd0b4f2d56efafbe3">More...</a><br /></td></tr>
+<tr class="separator:ga31061f134d93297fd0b4f2d56efafbe3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga63ead6c4883a6553446594e6027dc96c"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 > </td></tr>
+<tr class="memitem:ga63ead6c4883a6553446594e6027dc96c"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__mem__functor1.html">bound_const_mem_functor1</a>< T_return, T_obj, T_arg1 >, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga63ead6c4883a6553446594e6027dc96c">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__const__mem__functor1.html">bound_const_mem_functor1</a>< T_return, T_obj, T_arg1 > & _A_functor)</td></tr>
+<tr class="memdesc:ga63ead6c4883a6553446594e6027dc96c"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga63ead6c4883a6553446594e6027dc96c">More...</a><br /></td></tr>
+<tr class="separator:ga63ead6c4883a6553446594e6027dc96c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga415bd3f44f1785ce30452a4ca8e46dd0"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:ga415bd3f44f1785ce30452a4ca8e46dd0"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__mem__functor2.html">bound_const_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga415bd3f44f1785ce30452a4ca8e46dd0">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__const__mem__functor2.html">bound_const_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > & _A_functor)</td></tr>
+<tr class="memdesc:ga415bd3f44f1785ce30452a4ca8e46dd0"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga415bd3f44f1785ce30452a4ca8e46dd0">More...</a><br /></td></tr>
+<tr class="separator:ga415bd3f44f1785ce30452a4ca8e46dd0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga6f86026b9959cdd62287b29407c71e97"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:ga6f86026b9959cdd62287b29407c71e97"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__mem__functor3.html">bound_const_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga6f86026b9959cdd62287b29407c71e97">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__const__mem__functor3.html">bound_const_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > & _A_functor)</td></tr>
+<tr class="memdesc:ga6f86026b9959cdd62287b29407c71e97"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga6f86026b9959cdd62287b29407c71e97">More...</a><br /></td></tr>
+<tr class="separator:ga6f86026b9959cdd62287b29407c71e97"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga8fbc58cc94f7f4a46c1557091974a278"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:ga8fbc58cc94f7f4a46c1557091974a278"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__mem__functor4.html">bound_const_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga8fbc58cc94f7f4a46c1557091974a278">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__const__mem__functor4.html">bound_const_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > & _A_functor)</td></tr>
+<tr class="memdesc:ga8fbc58cc94f7f4a46c1557091974a278"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga8fbc58cc94f7f4a46c1557091974a278">More...</a><br /></td></tr>
+<tr class="separator:ga8fbc58cc94f7f4a46c1557091974a278"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga1d0d963fa703a6f85b8002c3a405c00a"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:ga1d0d963fa703a6f85b8002c3a405c00a"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__mem__functor5.html">bound_const_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga1d0d963fa703a6f85b8002c3a405c00a">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__const__mem__functor5.html">bound_const_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > & _A_functor)</td></tr>
+<tr class="memdesc:ga1d0d963fa703a6f85b8002c3a405c00a"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga1d0d963fa703a6f85b8002c3a405c00a">More...</a><br /></td></tr>
+<tr class="separator:ga1d0d963fa703a6f85b8002c3a405c00a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga39ba6af86d75de1535e4fa8af1e6081b"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:ga39ba6af86d75de1535e4fa8af1e6081b"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__mem__functor6.html">bound_const_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga39ba6af86d75de1535e4fa8af1e6081b">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__const__mem__functor6.html">bound_const_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > & _A_functor)</td></tr>
+<tr class="memdesc:ga39ba6af86d75de1535e4fa8af1e6081b"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga39ba6af86d75de1535e4fa8af1e6081b">More...</a><br /></td></tr>
+<tr class="separator:ga39ba6af86d75de1535e4fa8af1e6081b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga02a44f2ea2386f8e4fa41cb582c2008d"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:ga02a44f2ea2386f8e4fa41cb582c2008d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__mem__functor7.html">bound_const_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga02a44f2ea2386f8e4fa41cb582c2008d">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__const__mem__functor7.html">bound_const_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & _A_functor)</td></tr>
+<tr class="memdesc:ga02a44f2ea2386f8e4fa41cb582c2008d"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga02a44f2ea2386f8e4fa41cb582c2008d">More...</a><br /></td></tr>
+<tr class="separator:ga02a44f2ea2386f8e4fa41cb582c2008d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gade9ed42b368ea6eee6d42c8116cd28dd"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj > </td></tr>
+<tr class="memitem:gade9ed42b368ea6eee6d42c8116cd28dd"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">bound_const_volatile_mem_functor0</a>< T_return, T_obj > > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gade9ed42b368ea6eee6d42c8116cd28dd">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">bound_const_volatile_mem_functor0</a>< T_return, T_obj > & _A_functor)</td></tr>
+<tr class="memdesc:gade9ed42b368ea6eee6d42c8116cd28dd"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gade9ed42b368ea6eee6d42c8116cd28dd">More...</a><br /></td></tr>
+<tr class="separator:gade9ed42b368ea6eee6d42c8116cd28dd"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaab22de279058fd53d5ef720ad3932b56"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 > </td></tr>
+<tr class="memitem:gaab22de279058fd53d5ef720ad3932b56"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">bound_const_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gaab22de279058fd53d5ef720ad3932b56">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">bound_const_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 > & _A_functor)</td></tr>
+<tr class="memdesc:gaab22de279058fd53d5ef720ad3932b56"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gaab22de279058fd53d5ef720ad3932b56">More...</a><br /></td></tr>
+<tr class="separator:gaab22de279058fd53d5ef720ad3932b56"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga42f7c6ae10273b6577909f89bd76dc1f"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:ga42f7c6ae10273b6577909f89bd76dc1f"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">bound_const_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga42f7c6ae10273b6577909f89bd76dc1f">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">bound_const_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > & _A_functor)</td></tr>
+<tr class="memdesc:ga42f7c6ae10273b6577909f89bd76dc1f"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga42f7c6ae10273b6577909f89bd76dc1f">More...</a><br /></td></tr>
+<tr class="separator:ga42f7c6ae10273b6577909f89bd76dc1f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga1b2477c6ed3347fae35c66f25977f9dc"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:ga1b2477c6ed3347fae35c66f25977f9dc"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">bound_const_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga1b2477c6ed3347fae35c66f25977f9dc">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">bound_const_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > & _A_functor)</td></tr>
+<tr class="memdesc:ga1b2477c6ed3347fae35c66f25977f9dc"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga1b2477c6ed3347fae35c66f25977f9dc">More...</a><br /></td></tr>
+<tr class="separator:ga1b2477c6ed3347fae35c66f25977f9dc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gad73b9445fab1544d7550db964426520d"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:gad73b9445fab1544d7550db964426520d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">bound_const_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gad73b9445fab1544d7550db964426520d">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">bound_const_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > & _A_functor)</td></tr>
+<tr class="memdesc:gad73b9445fab1544d7550db964426520d"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gad73b9445fab1544d7550db964426520d">More...</a><br /></td></tr>
+<tr class="separator:gad73b9445fab1544d7550db964426520d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gacbb4a1e1c3447205bf507d6912847015"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:gacbb4a1e1c3447205bf507d6912847015"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">bound_const_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gacbb4a1e1c3447205bf507d6912847015">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">bound_const_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > & _A_functor)</td></tr>
+<tr class="memdesc:gacbb4a1e1c3447205bf507d6912847015"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gacbb4a1e1c3447205bf507d6912847015">More...</a><br /></td></tr>
+<tr class="separator:gacbb4a1e1c3447205bf507d6912847015"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gace1ef4f9ca35373adaad3c29db2b918f"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:gace1ef4f9ca35373adaad3c29db2b918f"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">bound_const_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gace1ef4f9ca35373adaad3c29db2b918f">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">bound_const_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > & _A_functor)</td></tr>
+<tr class="memdesc:gace1ef4f9ca35373adaad3c29db2b918f"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gace1ef4f9ca35373adaad3c29db2b918f">More...</a><br /></td></tr>
+<tr class="separator:gace1ef4f9ca35373adaad3c29db2b918f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga1ec0f19b59050f8f01c8969835b3c742"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:ga1ec0f19b59050f8f01c8969835b3c742"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">bound_const_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga1ec0f19b59050f8f01c8969835b3c742">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">bound_const_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & _A_functor)</td></tr>
+<tr class="memdesc:ga1ec0f19b59050f8f01c8969835b3c742"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga1ec0f19b59050f8f01c8969835b3c742">More...</a><br /></td></tr>
+<tr class="separator:ga1ec0f19b59050f8f01c8969835b3c742"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaebe9c150af92e230257bbbdb728e5a07"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj > </td></tr>
+<tr class="memitem:gaebe9c150af92e230257bbbdb728e5a07"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__mem__functor0.html">bound_mem_functor0</a>< T_return, T_obj > > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gaebe9c150af92e230257bbbdb728e5a07">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__mem__functor0.html">bound_mem_functor0</a>< T_return, T_obj > & _A_functor)</td></tr>
+<tr class="memdesc:gaebe9c150af92e230257bbbdb728e5a07"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gaebe9c150af92e230257bbbdb728e5a07">More...</a><br /></td></tr>
+<tr class="separator:gaebe9c150af92e230257bbbdb728e5a07"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga971017d74a880ee10555ebd32483d188"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 > </td></tr>
+<tr class="memitem:ga971017d74a880ee10555ebd32483d188"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__mem__functor1.html">bound_mem_functor1</a>< T_return, T_obj, T_arg1 >, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga971017d74a880ee10555ebd32483d188">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__mem__functor1.html">bound_mem_functor1</a>< T_return, T_obj, T_arg1 > & _A_functor)</td></tr>
+<tr class="memdesc:ga971017d74a880ee10555ebd32483d188"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga971017d74a880ee10555ebd32483d188">More...</a><br /></td></tr>
+<tr class="separator:ga971017d74a880ee10555ebd32483d188"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaddf62506fc01f1cdfcadef27e47f9b59"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:gaddf62506fc01f1cdfcadef27e47f9b59"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__mem__functor2.html">bound_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gaddf62506fc01f1cdfcadef27e47f9b59">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__mem__functor2.html">bound_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > & _A_functor)</td></tr>
+<tr class="memdesc:gaddf62506fc01f1cdfcadef27e47f9b59"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gaddf62506fc01f1cdfcadef27e47f9b59">More...</a><br /></td></tr>
+<tr class="separator:gaddf62506fc01f1cdfcadef27e47f9b59"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gad916eb17d984df3b7da9b7d3d041168a"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:gad916eb17d984df3b7da9b7d3d041168a"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__mem__functor3.html">bound_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gad916eb17d984df3b7da9b7d3d041168a">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__mem__functor3.html">bound_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > & _A_functor)</td></tr>
+<tr class="memdesc:gad916eb17d984df3b7da9b7d3d041168a"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gad916eb17d984df3b7da9b7d3d041168a">More...</a><br /></td></tr>
+<tr class="separator:gad916eb17d984df3b7da9b7d3d041168a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga8362fa71a99b71b843205e0482b281fc"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:ga8362fa71a99b71b843205e0482b281fc"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__mem__functor4.html">bound_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga8362fa71a99b71b843205e0482b281fc">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__mem__functor4.html">bound_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > & _A_functor)</td></tr>
+<tr class="memdesc:ga8362fa71a99b71b843205e0482b281fc"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga8362fa71a99b71b843205e0482b281fc">More...</a><br /></td></tr>
+<tr class="separator:ga8362fa71a99b71b843205e0482b281fc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga9c139b3254f5020de44a73c7dd795819"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:ga9c139b3254f5020de44a73c7dd795819"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__mem__functor5.html">bound_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga9c139b3254f5020de44a73c7dd795819">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__mem__functor5.html">bound_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > & _A_functor)</td></tr>
+<tr class="memdesc:ga9c139b3254f5020de44a73c7dd795819"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga9c139b3254f5020de44a73c7dd795819">More...</a><br /></td></tr>
+<tr class="separator:ga9c139b3254f5020de44a73c7dd795819"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga12e152b4340f83bd1f6cec92771fa82a"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:ga12e152b4340f83bd1f6cec92771fa82a"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__mem__functor6.html">bound_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga12e152b4340f83bd1f6cec92771fa82a">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__mem__functor6.html">bound_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > & _A_functor)</td></tr>
+<tr class="memdesc:ga12e152b4340f83bd1f6cec92771fa82a"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga12e152b4340f83bd1f6cec92771fa82a">More...</a><br /></td></tr>
+<tr class="separator:ga12e152b4340f83bd1f6cec92771fa82a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gadda8029b543d9b657f01e6ba9a9ef8fd"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:gadda8029b543d9b657f01e6ba9a9ef8fd"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__mem__functor7.html">bound_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gadda8029b543d9b657f01e6ba9a9ef8fd">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__mem__functor7.html">bound_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & _A_functor)</td></tr>
+<tr class="memdesc:gadda8029b543d9b657f01e6ba9a9ef8fd"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gadda8029b543d9b657f01e6ba9a9ef8fd">More...</a><br /></td></tr>
+<tr class="separator:gadda8029b543d9b657f01e6ba9a9ef8fd"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gadc01bb77132048902ec8965d012edcd3"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj > </td></tr>
+<tr class="memitem:gadc01bb77132048902ec8965d012edcd3"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">bound_volatile_mem_functor0</a>< T_return, T_obj > > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gadc01bb77132048902ec8965d012edcd3">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">bound_volatile_mem_functor0</a>< T_return, T_obj > & _A_functor)</td></tr>
+<tr class="memdesc:gadc01bb77132048902ec8965d012edcd3"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gadc01bb77132048902ec8965d012edcd3">More...</a><br /></td></tr>
+<tr class="separator:gadc01bb77132048902ec8965d012edcd3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga45b921820c277072b6f7e856ddbcfca1"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 > </td></tr>
+<tr class="memitem:ga45b921820c277072b6f7e856ddbcfca1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">bound_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga45b921820c277072b6f7e856ddbcfca1">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">bound_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 > & _A_functor)</td></tr>
+<tr class="memdesc:ga45b921820c277072b6f7e856ddbcfca1"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga45b921820c277072b6f7e856ddbcfca1">More...</a><br /></td></tr>
+<tr class="separator:ga45b921820c277072b6f7e856ddbcfca1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaf420d79b4077b848ef1aef4b68810d6e"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:gaf420d79b4077b848ef1aef4b68810d6e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">bound_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gaf420d79b4077b848ef1aef4b68810d6e">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">bound_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > & _A_functor)</td></tr>
+<tr class="memdesc:gaf420d79b4077b848ef1aef4b68810d6e"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gaf420d79b4077b848ef1aef4b68810d6e">More...</a><br /></td></tr>
+<tr class="separator:gaf420d79b4077b848ef1aef4b68810d6e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga899ae79da0e918ad9fc8f2c8e8066218"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:ga899ae79da0e918ad9fc8f2c8e8066218"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">bound_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga899ae79da0e918ad9fc8f2c8e8066218">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">bound_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > & _A_functor)</td></tr>
+<tr class="memdesc:ga899ae79da0e918ad9fc8f2c8e8066218"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga899ae79da0e918ad9fc8f2c8e8066218">More...</a><br /></td></tr>
+<tr class="separator:ga899ae79da0e918ad9fc8f2c8e8066218"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga8540037bfd4da57495b60dd9487c6d0b"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:ga8540037bfd4da57495b60dd9487c6d0b"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">bound_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga8540037bfd4da57495b60dd9487c6d0b">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">bound_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > & _A_functor)</td></tr>
+<tr class="memdesc:ga8540037bfd4da57495b60dd9487c6d0b"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga8540037bfd4da57495b60dd9487c6d0b">More...</a><br /></td></tr>
+<tr class="separator:ga8540037bfd4da57495b60dd9487c6d0b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga31ace8220cbb70b8e7f545ee4c1b6610"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:ga31ace8220cbb70b8e7f545ee4c1b6610"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">bound_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga31ace8220cbb70b8e7f545ee4c1b6610">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">bound_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > & _A_functor)</td></tr>
+<tr class="memdesc:ga31ace8220cbb70b8e7f545ee4c1b6610"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga31ace8220cbb70b8e7f545ee4c1b6610">More...</a><br /></td></tr>
+<tr class="separator:ga31ace8220cbb70b8e7f545ee4c1b6610"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga9f45f05c95abc9d20ae9d39589f5d72e"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:ga9f45f05c95abc9d20ae9d39589f5d72e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">bound_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga9f45f05c95abc9d20ae9d39589f5d72e">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">bound_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > & _A_functor)</td></tr>
+<tr class="memdesc:ga9f45f05c95abc9d20ae9d39589f5d72e"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga9f45f05c95abc9d20ae9d39589f5d72e">More...</a><br /></td></tr>
+<tr class="separator:ga9f45f05c95abc9d20ae9d39589f5d72e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga17e8761db2fafa2d3a92d19d8ce47511"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:ga17e8761db2fafa2d3a92d19d8ce47511"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">bound_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga17e8761db2fafa2d3a92d19d8ce47511">sigc::retype</a> (const <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">bound_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & _A_functor)</td></tr>
+<tr class="memdesc:ga17e8761db2fafa2d3a92d19d8ce47511"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga17e8761db2fafa2d3a92d19d8ce47511">More...</a><br /></td></tr>
+<tr class="separator:ga17e8761db2fafa2d3a92d19d8ce47511"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga0688ca8eb3ee82e191563ba7f81366b2"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga0688ca8eb3ee82e191563ba7f81366b2"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__mem__functor0.html">const_mem_functor0</a>< T_return, T_obj > > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga0688ca8eb3ee82e191563ba7f81366b2">sigc::retype</a> (const <a class="el" href="classsigc_1_1const__mem__functor0.html">const_mem_functor0</a>< T_return, T_obj > & _A_functor)</td></tr>
+<tr class="memdesc:ga0688ca8eb3ee82e191563ba7f81366b2"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga0688ca8eb3ee82e191563ba7f81366b2">More...</a><br /></td></tr>
+<tr class="separator:ga0688ca8eb3ee82e191563ba7f81366b2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gae035134414ed79a187a6b41a115a3759"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 > </td></tr>
+<tr class="memitem:gae035134414ed79a187a6b41a115a3759"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__mem__functor1.html">const_mem_functor1</a>< T_return, T_obj, T_arg1 >, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gae035134414ed79a187a6b41a115a3759">sigc::retype</a> (const <a class="el" href="classsigc_1_1const__mem__functor1.html">const_mem_functor1</a>< T_return, T_obj, T_arg1 > & _A_functor)</td></tr>
+<tr class="memdesc:gae035134414ed79a187a6b41a115a3759"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gae035134414ed79a187a6b41a115a3759">More...</a><br /></td></tr>
+<tr class="separator:gae035134414ed79a187a6b41a115a3759"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga8e9ee582f601451f3aa7c3d37d03b952"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:ga8e9ee582f601451f3aa7c3d37d03b952"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__mem__functor2.html">const_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga8e9ee582f601451f3aa7c3d37d03b952">sigc::retype</a> (const <a class="el" href="classsigc_1_1const__mem__functor2.html">const_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > & _A_functor)</td></tr>
+<tr class="memdesc:ga8e9ee582f601451f3aa7c3d37d03b952"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga8e9ee582f601451f3aa7c3d37d03b952">More...</a><br /></td></tr>
+<tr class="separator:ga8e9ee582f601451f3aa7c3d37d03b952"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga81e06b857f7a44b0589125e28535f87f"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:ga81e06b857f7a44b0589125e28535f87f"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__mem__functor3.html">const_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga81e06b857f7a44b0589125e28535f87f">sigc::retype</a> (const <a class="el" href="classsigc_1_1const__mem__functor3.html">const_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > & _A_functor)</td></tr>
+<tr class="memdesc:ga81e06b857f7a44b0589125e28535f87f"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga81e06b857f7a44b0589125e28535f87f">More...</a><br /></td></tr>
+<tr class="separator:ga81e06b857f7a44b0589125e28535f87f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga411bdd3476f80d627c50d47149862ec2"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:ga411bdd3476f80d627c50d47149862ec2"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__mem__functor4.html">const_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga411bdd3476f80d627c50d47149862ec2">sigc::retype</a> (const <a class="el" href="classsigc_1_1const__mem__functor4.html">const_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > & _A_functor)</td></tr>
+<tr class="memdesc:ga411bdd3476f80d627c50d47149862ec2"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga411bdd3476f80d627c50d47149862ec2">More...</a><br /></td></tr>
+<tr class="separator:ga411bdd3476f80d627c50d47149862ec2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga995053759ee8ee89663f9625a4aaf596"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:ga995053759ee8ee89663f9625a4aaf596"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__mem__functor5.html">const_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga995053759ee8ee89663f9625a4aaf596">sigc::retype</a> (const <a class="el" href="classsigc_1_1const__mem__functor5.html">const_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > & _A_functor)</td></tr>
+<tr class="memdesc:ga995053759ee8ee89663f9625a4aaf596"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga995053759ee8ee89663f9625a4aaf596">More...</a><br /></td></tr>
+<tr class="separator:ga995053759ee8ee89663f9625a4aaf596"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga851188153c54bb1eb8fee425f9796981"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:ga851188153c54bb1eb8fee425f9796981"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__mem__functor6.html">const_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga851188153c54bb1eb8fee425f9796981">sigc::retype</a> (const <a class="el" href="classsigc_1_1const__mem__functor6.html">const_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > & _A_functor)</td></tr>
+<tr class="memdesc:ga851188153c54bb1eb8fee425f9796981"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga851188153c54bb1eb8fee425f9796981">More...</a><br /></td></tr>
+<tr class="separator:ga851188153c54bb1eb8fee425f9796981"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaa951debcabd066f8c3479617aaa9689e"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:gaa951debcabd066f8c3479617aaa9689e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__mem__functor7.html">const_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gaa951debcabd066f8c3479617aaa9689e">sigc::retype</a> (const <a class="el" href="classsigc_1_1const__mem__functor7.html">const_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & _A_functor)</td></tr>
+<tr class="memdesc:gaa951debcabd066f8c3479617aaa9689e"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gaa951debcabd066f8c3479617aaa9689e">More...</a><br /></td></tr>
+<tr class="separator:gaa951debcabd066f8c3479617aaa9689e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga312fca59eb8b4ca0e078b1cf7f407212"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga312fca59eb8b4ca0e078b1cf7f407212"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">const_volatile_mem_functor0</a>< T_return, T_obj > > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga312fca59eb8b4ca0e078b1cf7f407212">sigc::retype</a> (const <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">const_volatile_mem_functor0</a>< T_return, T_obj > & _A_functor)</td></tr>
+<tr class="memdesc:ga312fca59eb8b4ca0e078b1cf7f407212"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga312fca59eb8b4ca0e078b1cf7f407212">More...</a><br /></td></tr>
+<tr class="separator:ga312fca59eb8b4ca0e078b1cf7f407212"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga84f4247ab4cc559aed835ccd943fab70"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 > </td></tr>
+<tr class="memitem:ga84f4247ab4cc559aed835ccd943fab70"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">const_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga84f4247ab4cc559aed835ccd943fab70">sigc::retype</a> (const <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">const_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 > & _A_functor)</td></tr>
+<tr class="memdesc:ga84f4247ab4cc559aed835ccd943fab70"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga84f4247ab4cc559aed835ccd943fab70">More...</a><br /></td></tr>
+<tr class="separator:ga84f4247ab4cc559aed835ccd943fab70"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga271911579dfbac317a53f62f0773e420"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:ga271911579dfbac317a53f62f0773e420"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">const_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga271911579dfbac317a53f62f0773e420">sigc::retype</a> (const <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">const_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > & _A_functor)</td></tr>
+<tr class="memdesc:ga271911579dfbac317a53f62f0773e420"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga271911579dfbac317a53f62f0773e420">More...</a><br /></td></tr>
+<tr class="separator:ga271911579dfbac317a53f62f0773e420"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga97b4f14b5a7991eba60b635871d6a7f9"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:ga97b4f14b5a7991eba60b635871d6a7f9"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">const_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga97b4f14b5a7991eba60b635871d6a7f9">sigc::retype</a> (const <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">const_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > & _A_functor)</td></tr>
+<tr class="memdesc:ga97b4f14b5a7991eba60b635871d6a7f9"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga97b4f14b5a7991eba60b635871d6a7f9">More...</a><br /></td></tr>
+<tr class="separator:ga97b4f14b5a7991eba60b635871d6a7f9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga4e9179cc61db0069db209bc7632b3dee"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:ga4e9179cc61db0069db209bc7632b3dee"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">const_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga4e9179cc61db0069db209bc7632b3dee">sigc::retype</a> (const <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">const_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > & _A_functor)</td></tr>
+<tr class="memdesc:ga4e9179cc61db0069db209bc7632b3dee"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga4e9179cc61db0069db209bc7632b3dee">More...</a><br /></td></tr>
+<tr class="separator:ga4e9179cc61db0069db209bc7632b3dee"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga637af7b3e60f5657dcd62e350ec76675"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:ga637af7b3e60f5657dcd62e350ec76675"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">const_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga637af7b3e60f5657dcd62e350ec76675">sigc::retype</a> (const <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">const_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > & _A_functor)</td></tr>
+<tr class="memdesc:ga637af7b3e60f5657dcd62e350ec76675"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga637af7b3e60f5657dcd62e350ec76675">More...</a><br /></td></tr>
+<tr class="separator:ga637af7b3e60f5657dcd62e350ec76675"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga17ceafe96cdf3bd37ccd401f413f8748"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:ga17ceafe96cdf3bd37ccd401f413f8748"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">const_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga17ceafe96cdf3bd37ccd401f413f8748">sigc::retype</a> (const <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">const_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > & _A_functor)</td></tr>
+<tr class="memdesc:ga17ceafe96cdf3bd37ccd401f413f8748"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga17ceafe96cdf3bd37ccd401f413f8748">More...</a><br /></td></tr>
+<tr class="separator:ga17ceafe96cdf3bd37ccd401f413f8748"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga75578233ce4f47c5f610569a5ffe84cc"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:ga75578233ce4f47c5f610569a5ffe84cc"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">const_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga75578233ce4f47c5f610569a5ffe84cc">sigc::retype</a> (const <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">const_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & _A_functor)</td></tr>
+<tr class="memdesc:ga75578233ce4f47c5f610569a5ffe84cc"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga75578233ce4f47c5f610569a5ffe84cc">More...</a><br /></td></tr>
+<tr class="separator:ga75578233ce4f47c5f610569a5ffe84cc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gabb08dd87f3ec392536b656b6b3e959a0"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj > </td></tr>
+<tr class="memitem:gabb08dd87f3ec392536b656b6b3e959a0"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1mem__functor0.html">mem_functor0</a>< T_return, T_obj > > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gabb08dd87f3ec392536b656b6b3e959a0">sigc::retype</a> (const <a class="el" href="classsigc_1_1mem__functor0.html">mem_functor0</a>< T_return, T_obj > & _A_functor)</td></tr>
+<tr class="memdesc:gabb08dd87f3ec392536b656b6b3e959a0"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gabb08dd87f3ec392536b656b6b3e959a0">More...</a><br /></td></tr>
+<tr class="separator:gabb08dd87f3ec392536b656b6b3e959a0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga5a2600190453d4eb11c14f99973044bc"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 > </td></tr>
+<tr class="memitem:ga5a2600190453d4eb11c14f99973044bc"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1mem__functor1.html">mem_functor1</a>< T_return, T_obj, T_arg1 >, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga5a2600190453d4eb11c14f99973044bc">sigc::retype</a> (const <a class="el" href="classsigc_1_1mem__functor1.html">mem_functor1</a>< T_return, T_obj, T_arg1 > & _A_functor)</td></tr>
+<tr class="memdesc:ga5a2600190453d4eb11c14f99973044bc"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga5a2600190453d4eb11c14f99973044bc">More...</a><br /></td></tr>
+<tr class="separator:ga5a2600190453d4eb11c14f99973044bc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga7df338186f09b1c89c2840f6744362e9"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:ga7df338186f09b1c89c2840f6744362e9"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1mem__functor2.html">mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga7df338186f09b1c89c2840f6744362e9">sigc::retype</a> (const <a class="el" href="classsigc_1_1mem__functor2.html">mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > & _A_functor)</td></tr>
+<tr class="memdesc:ga7df338186f09b1c89c2840f6744362e9"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga7df338186f09b1c89c2840f6744362e9">More...</a><br /></td></tr>
+<tr class="separator:ga7df338186f09b1c89c2840f6744362e9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gae2d9d2e91b2f8d256e4ad8da1c3c59e0"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:gae2d9d2e91b2f8d256e4ad8da1c3c59e0"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1mem__functor3.html">mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gae2d9d2e91b2f8d256e4ad8da1c3c59e0">sigc::retype</a> (const <a class="el" href="classsigc_1_1mem__functor3.html">mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > & _A_functor)</td></tr>
+<tr class="memdesc:gae2d9d2e91b2f8d256e4ad8da1c3c59e0"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gae2d9d2e91b2f8d256e4ad8da1c3c59e0">More...</a><br /></td></tr>
+<tr class="separator:gae2d9d2e91b2f8d256e4ad8da1c3c59e0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga70e615639e07e90a997a378cf877b106"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:ga70e615639e07e90a997a378cf877b106"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1mem__functor4.html">mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga70e615639e07e90a997a378cf877b106">sigc::retype</a> (const <a class="el" href="classsigc_1_1mem__functor4.html">mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > & _A_functor)</td></tr>
+<tr class="memdesc:ga70e615639e07e90a997a378cf877b106"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga70e615639e07e90a997a378cf877b106">More...</a><br /></td></tr>
+<tr class="separator:ga70e615639e07e90a997a378cf877b106"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gad225dee1d71c68d0ee71f3f0fedcfc1b"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:gad225dee1d71c68d0ee71f3f0fedcfc1b"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1mem__functor5.html">mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gad225dee1d71c68d0ee71f3f0fedcfc1b">sigc::retype</a> (const <a class="el" href="classsigc_1_1mem__functor5.html">mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > & _A_functor)</td></tr>
+<tr class="memdesc:gad225dee1d71c68d0ee71f3f0fedcfc1b"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gad225dee1d71c68d0ee71f3f0fedcfc1b">More...</a><br /></td></tr>
+<tr class="separator:gad225dee1d71c68d0ee71f3f0fedcfc1b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga9c08fe50076854f15c923ab4183aed0f"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:ga9c08fe50076854f15c923ab4183aed0f"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1mem__functor6.html">mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga9c08fe50076854f15c923ab4183aed0f">sigc::retype</a> (const <a class="el" href="classsigc_1_1mem__functor6.html">mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > & _A_functor)</td></tr>
+<tr class="memdesc:ga9c08fe50076854f15c923ab4183aed0f"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga9c08fe50076854f15c923ab4183aed0f">More...</a><br /></td></tr>
+<tr class="separator:ga9c08fe50076854f15c923ab4183aed0f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga3fbd72b71a4ea4fafa487b5932acd797"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:ga3fbd72b71a4ea4fafa487b5932acd797"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1mem__functor7.html">mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga3fbd72b71a4ea4fafa487b5932acd797">sigc::retype</a> (const <a class="el" href="classsigc_1_1mem__functor7.html">mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & _A_functor)</td></tr>
+<tr class="memdesc:ga3fbd72b71a4ea4fafa487b5932acd797"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga3fbd72b71a4ea4fafa487b5932acd797">More...</a><br /></td></tr>
+<tr class="separator:ga3fbd72b71a4ea4fafa487b5932acd797"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga23978c94d9d3c934803898c3bf48ff7d"><td class="memTemplParams" colspan="2">template<class T_return > </td></tr>
+<tr class="memitem:ga23978c94d9d3c934803898c3bf48ff7d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1pointer__functor0.html">pointer_functor0</a>< T_return > > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga23978c94d9d3c934803898c3bf48ff7d">sigc::retype</a> (const <a class="el" href="classsigc_1_1pointer__functor0.html">pointer_functor0</a>< T_return > & _A_functor)</td></tr>
+<tr class="memdesc:ga23978c94d9d3c934803898c3bf48ff7d"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga23978c94d9d3c934803898c3bf48ff7d">More...</a><br /></td></tr>
+<tr class="separator:ga23978c94d9d3c934803898c3bf48ff7d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga75cc92c15faf06d5293ff34179f21899"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return > </td></tr>
+<tr class="memitem:ga75cc92c15faf06d5293ff34179f21899"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1pointer__functor1.html">pointer_functor1</a>< T_arg1, T_return >, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga75cc92c15faf06d5293ff34179f21899">sigc::retype</a> (const <a class="el" href="classsigc_1_1pointer__functor1.html">pointer_functor1</a>< T_arg1, T_return > & _A_functor)</td></tr>
+<tr class="memdesc:ga75cc92c15faf06d5293ff34179f21899"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga75cc92c15faf06d5293ff34179f21899">More...</a><br /></td></tr>
+<tr class="separator:ga75cc92c15faf06d5293ff34179f21899"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga0d67e207b3d753ab71b3801981cfeff3"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return > </td></tr>
+<tr class="memitem:ga0d67e207b3d753ab71b3801981cfeff3"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1pointer__functor2.html">pointer_functor2</a>< T_arg1, T_arg2, T_return >, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga0d67e207b3d753ab71b3801981cfeff3">sigc::retype</a> (const <a class="el" href="classsigc_1_1pointer__functor2.html">pointer_functor2</a>< T_arg1, T_arg2, T_return > & _A_functor)</td></tr>
+<tr class="memdesc:ga0d67e207b3d753ab71b3801981cfeff3"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga0d67e207b3d753ab71b3801981cfeff3">More...</a><br /></td></tr>
+<tr class="separator:ga0d67e207b3d753ab71b3801981cfeff3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaa5dfa926e3bfc7b82e0d14e4d9c9ff32"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return > </td></tr>
+<tr class="memitem:gaa5dfa926e3bfc7b82e0d14e4d9c9ff32"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1pointer__functor3.html">pointer_functor3</a>< T_arg1, T_arg2, T_arg3, T_return >, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gaa5dfa926e3bfc7b82e0d14e4d9c9ff32">sigc::retype</a> (const <a class="el" href="classsigc_1_1pointer__functor3.html">pointer_functor3</a>< T_arg1, T_arg2, T_arg3, T_return > & _A_functor)</td></tr>
+<tr class="memdesc:gaa5dfa926e3bfc7b82e0d14e4d9c9ff32"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gaa5dfa926e3bfc7b82e0d14e4d9c9ff32">More...</a><br /></td></tr>
+<tr class="separator:gaa5dfa926e3bfc7b82e0d14e4d9c9ff32"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gade02a3d76cf35465acfa39d4e03a40d5"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return > </td></tr>
+<tr class="memitem:gade02a3d76cf35465acfa39d4e03a40d5"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1pointer__functor4.html">pointer_functor4</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_return >, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gade02a3d76cf35465acfa39d4e03a40d5">sigc::retype</a> (const <a class="el" href="classsigc_1_1pointer__functor4.html">pointer_functor4</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_return > & _A_functor)</td></tr>
+<tr class="memdesc:gade02a3d76cf35465acfa39d4e03a40d5"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gade02a3d76cf35465acfa39d4e03a40d5">More...</a><br /></td></tr>
+<tr class="separator:gade02a3d76cf35465acfa39d4e03a40d5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga45fa726d6497c6b0994444fd2569581c"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return > </td></tr>
+<tr class="memitem:ga45fa726d6497c6b0994444fd2569581c"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1pointer__functor5.html">pointer_functor5</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga45fa726d6497c6b0994444fd2569581c">sigc::retype</a> (const <a class="el" href="classsigc_1_1pointer__functor5.html">pointer_functor5</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return > & _A_functor)</td></tr>
+<tr class="memdesc:ga45fa726d6497c6b0994444fd2569581c"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga45fa726d6497c6b0994444fd2569581c">More...</a><br /></td></tr>
+<tr class="separator:ga45fa726d6497c6b0994444fd2569581c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga24e30de09c3784220829f52bb068b8c0"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return > </td></tr>
+<tr class="memitem:ga24e30de09c3784220829f52bb068b8c0"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1pointer__functor6.html">pointer_functor6</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga24e30de09c3784220829f52bb068b8c0">sigc::retype</a> (const <a class="el" href="classsigc_1_1pointer__functor6.html">pointer_functor6</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return > & _A_functor)</td></tr>
+<tr class="memdesc:ga24e30de09c3784220829f52bb068b8c0"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga24e30de09c3784220829f52bb068b8c0">More...</a><br /></td></tr>
+<tr class="separator:ga24e30de09c3784220829f52bb068b8c0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga09db0b458651a7fcd985e5dd4e50caa0"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return > </td></tr>
+<tr class="memitem:ga09db0b458651a7fcd985e5dd4e50caa0"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1pointer__functor7.html">pointer_functor7</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga09db0b458651a7fcd985e5dd4e50caa0">sigc::retype</a> (const <a class="el" href="classsigc_1_1pointer__functor7.html">pointer_functor7</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return > & _A_functor)</td></tr>
+<tr class="memdesc:ga09db0b458651a7fcd985e5dd4e50caa0"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga09db0b458651a7fcd985e5dd4e50caa0">More...</a><br /></td></tr>
+<tr class="separator:ga09db0b458651a7fcd985e5dd4e50caa0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga8b98eeb2a61b5b1f84dcd1d20fe666f1"><td class="memTemplParams" colspan="2">template<class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:ga8b98eeb2a61b5b1f84dcd1d20fe666f1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga8b98eeb2a61b5b1f84dcd1d20fe666f1">sigc::retype</a> (const <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & _A_functor)</td></tr>
+<tr class="memdesc:ga8b98eeb2a61b5b1f84dcd1d20fe666f1"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga8b98eeb2a61b5b1f84dcd1d20fe666f1">More...</a><br /></td></tr>
+<tr class="separator:ga8b98eeb2a61b5b1f84dcd1d20fe666f1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga53d620659c82cbb84da3812ac874f4b7"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga53d620659c82cbb84da3812ac874f4b7"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1volatile__mem__functor0.html">volatile_mem_functor0</a>< T_return, T_obj > > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga53d620659c82cbb84da3812ac874f4b7">sigc::retype</a> (const <a class="el" href="classsigc_1_1volatile__mem__functor0.html">volatile_mem_functor0</a>< T_return, T_obj > & _A_functor)</td></tr>
+<tr class="memdesc:ga53d620659c82cbb84da3812ac874f4b7"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga53d620659c82cbb84da3812ac874f4b7">More...</a><br /></td></tr>
+<tr class="separator:ga53d620659c82cbb84da3812ac874f4b7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga6d7f05b930056183bc7537447c80e59b"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 > </td></tr>
+<tr class="memitem:ga6d7f05b930056183bc7537447c80e59b"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1volatile__mem__functor1.html">volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga6d7f05b930056183bc7537447c80e59b">sigc::retype</a> (const <a class="el" href="classsigc_1_1volatile__mem__functor1.html">volatile_mem_functor1</a>< T_return, T_obj, T_arg1 > & _A_functor)</td></tr>
+<tr class="memdesc:ga6d7f05b930056183bc7537447c80e59b"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga6d7f05b930056183bc7537447c80e59b">More...</a><br /></td></tr>
+<tr class="separator:ga6d7f05b930056183bc7537447c80e59b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga5b65e9a9794300c40b1577302e006fbd"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:ga5b65e9a9794300c40b1577302e006fbd"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1volatile__mem__functor2.html">volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga5b65e9a9794300c40b1577302e006fbd">sigc::retype</a> (const <a class="el" href="classsigc_1_1volatile__mem__functor2.html">volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > & _A_functor)</td></tr>
+<tr class="memdesc:ga5b65e9a9794300c40b1577302e006fbd"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga5b65e9a9794300c40b1577302e006fbd">More...</a><br /></td></tr>
+<tr class="separator:ga5b65e9a9794300c40b1577302e006fbd"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga55236721b80a72f40453d1b939316635"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:ga55236721b80a72f40453d1b939316635"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1volatile__mem__functor3.html">volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga55236721b80a72f40453d1b939316635">sigc::retype</a> (const <a class="el" href="classsigc_1_1volatile__mem__functor3.html">volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > & _A_functor)</td></tr>
+<tr class="memdesc:ga55236721b80a72f40453d1b939316635"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga55236721b80a72f40453d1b939316635">More...</a><br /></td></tr>
+<tr class="separator:ga55236721b80a72f40453d1b939316635"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga05d2c3c043bed420ba8ba6f40f42f692"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:ga05d2c3c043bed420ba8ba6f40f42f692"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1volatile__mem__functor4.html">volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga05d2c3c043bed420ba8ba6f40f42f692">sigc::retype</a> (const <a class="el" href="classsigc_1_1volatile__mem__functor4.html">volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > & _A_functor)</td></tr>
+<tr class="memdesc:ga05d2c3c043bed420ba8ba6f40f42f692"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga05d2c3c043bed420ba8ba6f40f42f692">More...</a><br /></td></tr>
+<tr class="separator:ga05d2c3c043bed420ba8ba6f40f42f692"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga42be2d2fbf03fbaba1ad7d8cbbb8bce4"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:ga42be2d2fbf03fbaba1ad7d8cbbb8bce4"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1volatile__mem__functor5.html">volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga42be2d2fbf03fbaba1ad7d8cbbb8bce4">sigc::retype</a> (const <a class="el" href="classsigc_1_1volatile__mem__functor5.html">volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > & _A_functor)</td></tr>
+<tr class="memdesc:ga42be2d2fbf03fbaba1ad7d8cbbb8bce4"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga42be2d2fbf03fbaba1ad7d8cbbb8bce4">More...</a><br /></td></tr>
+<tr class="separator:ga42be2d2fbf03fbaba1ad7d8cbbb8bce4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga255fac4b456d69d033b327b1d533f054"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:ga255fac4b456d69d033b327b1d533f054"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1volatile__mem__functor6.html">volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga255fac4b456d69d033b327b1d533f054">sigc::retype</a> (const <a class="el" href="classsigc_1_1volatile__mem__functor6.html">volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > & _A_functor)</td></tr>
+<tr class="memdesc:ga255fac4b456d69d033b327b1d533f054"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga255fac4b456d69d033b327b1d533f054">More...</a><br /></td></tr>
+<tr class="separator:ga255fac4b456d69d033b327b1d533f054"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga37a057f88e6ffbb8d4172d6446116796"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:ga37a057f88e6ffbb8d4172d6446116796"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1volatile__mem__functor7.html">volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga37a057f88e6ffbb8d4172d6446116796">sigc::retype</a> (const <a class="el" href="classsigc_1_1volatile__mem__functor7.html">volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & _A_functor)</td></tr>
+<tr class="memdesc:ga37a057f88e6ffbb8d4172d6446116796"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga37a057f88e6ffbb8d4172d6446116796">More...</a><br /></td></tr>
+<tr class="separator:ga37a057f88e6ffbb8d4172d6446116796"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga23a8cdbc12c57fbef0866b5c51d71588"><td class="memTemplParams" colspan="2">template<class T_return , class T_functor > </td></tr>
+<tr class="memitem:ga23a8cdbc12c57fbef0866b5c51d71588"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__return__functor.html">retype_return_functor</a>< T_return, T_functor > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga23a8cdbc12c57fbef0866b5c51d71588">sigc::retype_return</a> (const T_functor & _A_functor)</td></tr>
+<tr class="memdesc:ga23a8cdbc12c57fbef0866b5c51d71588"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__return__functor.html" title="Adaptor that performs a C-style cast on the return value of a functor.">sigc::retype_return_functor</a> which performs a C-style cast on the return value of the passed functor. <a href="group__retype.html#ga23a8cdbc12c57fbef0866b5c51d71588">More...</a><br /></td></tr>
+<tr class="separator:ga23a8cdbc12c57fbef0866b5c51d71588"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<p><a class="el" href="group__retype.html#ga8b98eeb2a61b5b1f84dcd1d20fe666f1" title="Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed...">sigc::retype()</a> alters a sigc::pointer_functor, a sigc::mem_functor or a <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> in that it makes C-style casts to the functor's parameter types of all parameters passed through operator()(). </p>
+<p>Use this adaptor for inline conversion between numeric or other simple types. </p><dl class="section user"><dt>Example:</dt><dd><div class="fragment"><div class="line"><span class="keywordtype">void</span> foo(<span class="keywordtype">int</span>);</div>
+<div class="line"><a class="code" href="group__retype.html#ga8b98eeb2a61b5b1f84dcd1d20fe666f1">sigc::retype</a>(<a class="code" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863">sigc::ptr_fun</a>(&foo))(5.7F); <span class="comment">// calls foo(5)</span></div>
+<div class="ttc" id="agroup__ptr__fun_html_ga9c80de72f656fb05e81fda622dddc863"><div class="ttname"><a href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863">sigc::ptr_fun</a></div><div class="ttdeci">pointer_functor0< T_return > ptr_fun(T_return(*_A_func)())</div><div class="ttdoc">Creates a functor of type sigc::pointer_functor0 which wraps an existing non-member function.</div><div class="ttdef"><b>Definition:</b> ptr_fun.h:460</div></div>
+<div class="ttc" id="agroup__retype_html_ga8b98eeb2a61b5b1f84dcd1d20fe666f1"><div class="ttname"><a href="group__retype.html#ga8b98eeb2a61b5b1f84dcd1d20fe666f1">sigc::retype</a></div><div class="ttdeci">retype_functor< slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > retype(const slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > &_A_functor)</div><div class="ttdoc">Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed...</div><div class="ttdef"><b>Definition:</b> retype.h:245</div></div>
+</div><!-- fragment --></dd></dl>
+<p>The functor that <a class="el" href="group__retype.html#ga8b98eeb2a61b5b1f84dcd1d20fe666f1" title="Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed...">sigc::retype()</a> returns can be passed directly into <a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2" title="Add a slot to the list of slots.">sigc::signal::connect()</a>.</p>
+<dl class="section user"><dt>Example:</dt><dd><div class="fragment"><div class="line"><a class="code" href="classsigc_1_1signal.html">sigc::signal<void,float></a> some_signal;</div>
+<div class="line"><span class="keywordtype">void</span> foo(<span class="keywordtype">int</span>);</div>
+<div class="line">some_signal.<a class="code" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">connect</a>(<a class="code" href="group__retype.html#ga8b98eeb2a61b5b1f84dcd1d20fe666f1">sigc::retype</a>(<a class="code" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863">sigc::ptr_fun</a>(&foo)));</div>
+<div class="ttc" id="aclasssigc_1_1signal7_html_adc55ac9b0f935fd87a67904022e03cb2"><div class="ttname"><a href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">sigc::signal7::connect</a></div><div class="ttdeci">iterator connect(const slot_type &slot_)</div><div class="ttdoc">Add a slot to the list of slots.</div><div class="ttdef"><b>Definition:</b> signal.h:3871</div></div>
+<div class="ttc" id="aclasssigc_1_1signal_html"><div class="ttname"><a href="classsigc_1_1signal.html">sigc::signal</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::signal# templates.</div><div class="ttdef"><b>Definition:</b> signal.h:4015</div></div>
+</div><!-- fragment --></dd></dl>
+<p>This adaptor builds an exception in that it only works on sig::pointer_functor, sigc::mem_functor and <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> because it needs sophisticated information about the parameter types that cannot be deduced from arbitrary functor types.</p>
+<p><a class="el" href="group__retype.html#ga23a8cdbc12c57fbef0866b5c51d71588" title="Creates an adaptor of type sigc::retype_return_functor which performs a C-style cast on the return va...">sigc::retype_return()</a> alters the return type of an arbitrary functor. Like in <a class="el" href="group__retype.html#ga8b98eeb2a61b5b1f84dcd1d20fe666f1" title="Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed...">sigc::retype()</a> a C-style cast is performed. Usage <a class="el" href="group__retype.html#ga23a8cdbc12c57fbef0866b5c51d71588" title="Creates an adaptor of type sigc::retype_return_functor which performs a C-style cast on the return va...">sigc::retype_return()</a> is not restricted to libsigc++ functor types but you need to specify the new return type as a template parameter.</p>
+<dl class="section user"><dt>Example:</dt><dd><div class="fragment"><div class="line"><span class="keywordtype">float</span> foo();</div>
+<div class="line">std::cout << sigc::retype_return<int>(&foo)(); <span class="comment">// converts foo's return value to an integer</span></div>
+</div><!-- fragment --> </dd></dl>
+<h2 class="groupheader">Function Documentation</h2>
+<a id="ga31061f134d93297fd0b4f2d56efafbe3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga31061f134d93297fd0b4f2d56efafbe3">◆ </a></span>retype() <span class="overload">[1/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__const__mem__functor0.html">bound_const_mem_functor0</a><T_return, T_obj> > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__const__mem__functor0.html">bound_const_mem_functor0</a>< T_return, T_obj > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_const_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga63ead6c4883a6553446594e6027dc96c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga63ead6c4883a6553446594e6027dc96c">◆ </a></span>retype() <span class="overload">[2/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__const__mem__functor1.html">bound_const_mem_functor1</a><T_return, T_obj, T_arg1>, T_arg1 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__const__mem__functor1.html">bound_const_mem_functor1</a>< T_return, T_obj, T_arg1 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_const_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga415bd3f44f1785ce30452a4ca8e46dd0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga415bd3f44f1785ce30452a4ca8e46dd0">◆ </a></span>retype() <span class="overload">[3/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__const__mem__functor2.html">bound_const_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__const__mem__functor2.html">bound_const_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_const_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga6f86026b9959cdd62287b29407c71e97"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga6f86026b9959cdd62287b29407c71e97">◆ </a></span>retype() <span class="overload">[4/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__const__mem__functor3.html">bound_const_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__const__mem__functor3.html">bound_const_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_const_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga8fbc58cc94f7f4a46c1557091974a278"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga8fbc58cc94f7f4a46c1557091974a278">◆ </a></span>retype() <span class="overload">[5/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__const__mem__functor4.html">bound_const_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1, T_arg2, T_arg3, T_arg4 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__const__mem__functor4.html">bound_const_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_const_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga1d0d963fa703a6f85b8002c3a405c00a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga1d0d963fa703a6f85b8002c3a405c00a">◆ </a></span>retype() <span class="overload">[6/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__const__mem__functor5.html">bound_const_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__const__mem__functor5.html">bound_const_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_const_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga39ba6af86d75de1535e4fa8af1e6081b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga39ba6af86d75de1535e4fa8af1e6081b">◆ </a></span>retype() <span class="overload">[7/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__const__mem__functor6.html">bound_const_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__const__mem__functor6.html">bound_const_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_const_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga02a44f2ea2386f8e4fa41cb582c2008d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga02a44f2ea2386f8e4fa41cb582c2008d">◆ </a></span>retype() <span class="overload">[8/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__const__mem__functor7.html">bound_const_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__const__mem__functor7.html">bound_const_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_const_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="gade9ed42b368ea6eee6d42c8116cd28dd"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gade9ed42b368ea6eee6d42c8116cd28dd">◆ </a></span>retype() <span class="overload">[9/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">bound_const_volatile_mem_functor0</a><T_return, T_obj> > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">bound_const_volatile_mem_functor0</a>< T_return, T_obj > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_const_volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="gaab22de279058fd53d5ef720ad3932b56"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaab22de279058fd53d5ef720ad3932b56">◆ </a></span>retype() <span class="overload">[10/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">bound_const_volatile_mem_functor1</a><T_return, T_obj, T_arg1>, T_arg1 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">bound_const_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_const_volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga42f7c6ae10273b6577909f89bd76dc1f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga42f7c6ae10273b6577909f89bd76dc1f">◆ </a></span>retype() <span class="overload">[11/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">bound_const_volatile_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">bound_const_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_const_volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga1b2477c6ed3347fae35c66f25977f9dc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga1b2477c6ed3347fae35c66f25977f9dc">◆ </a></span>retype() <span class="overload">[12/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">bound_const_volatile_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">bound_const_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_const_volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="gad73b9445fab1544d7550db964426520d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gad73b9445fab1544d7550db964426520d">◆ </a></span>retype() <span class="overload">[13/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">bound_const_volatile_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1, T_arg2, T_arg3, T_arg4 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">bound_const_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_const_volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="gacbb4a1e1c3447205bf507d6912847015"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gacbb4a1e1c3447205bf507d6912847015">◆ </a></span>retype() <span class="overload">[14/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">bound_const_volatile_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">bound_const_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_const_volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="gace1ef4f9ca35373adaad3c29db2b918f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gace1ef4f9ca35373adaad3c29db2b918f">◆ </a></span>retype() <span class="overload">[15/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">bound_const_volatile_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">bound_const_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_const_volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga1ec0f19b59050f8f01c8969835b3c742"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga1ec0f19b59050f8f01c8969835b3c742">◆ </a></span>retype() <span class="overload">[16/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">bound_const_volatile_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">bound_const_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_const_volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="gaebe9c150af92e230257bbbdb728e5a07"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaebe9c150af92e230257bbbdb728e5a07">◆ </a></span>retype() <span class="overload">[17/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__mem__functor0.html">bound_mem_functor0</a><T_return, T_obj> > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__mem__functor0.html">bound_mem_functor0</a>< T_return, T_obj > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga971017d74a880ee10555ebd32483d188"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga971017d74a880ee10555ebd32483d188">◆ </a></span>retype() <span class="overload">[18/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__mem__functor1.html">bound_mem_functor1</a><T_return, T_obj, T_arg1>, T_arg1 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__mem__functor1.html">bound_mem_functor1</a>< T_return, T_obj, T_arg1 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="gaddf62506fc01f1cdfcadef27e47f9b59"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaddf62506fc01f1cdfcadef27e47f9b59">◆ </a></span>retype() <span class="overload">[19/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__mem__functor2.html">bound_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__mem__functor2.html">bound_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="gad916eb17d984df3b7da9b7d3d041168a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gad916eb17d984df3b7da9b7d3d041168a">◆ </a></span>retype() <span class="overload">[20/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__mem__functor3.html">bound_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__mem__functor3.html">bound_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga8362fa71a99b71b843205e0482b281fc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga8362fa71a99b71b843205e0482b281fc">◆ </a></span>retype() <span class="overload">[21/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__mem__functor4.html">bound_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1, T_arg2, T_arg3, T_arg4 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__mem__functor4.html">bound_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga9c139b3254f5020de44a73c7dd795819"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga9c139b3254f5020de44a73c7dd795819">◆ </a></span>retype() <span class="overload">[22/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__mem__functor5.html">bound_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__mem__functor5.html">bound_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga12e152b4340f83bd1f6cec92771fa82a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga12e152b4340f83bd1f6cec92771fa82a">◆ </a></span>retype() <span class="overload">[23/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__mem__functor6.html">bound_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__mem__functor6.html">bound_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="gadda8029b543d9b657f01e6ba9a9ef8fd"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gadda8029b543d9b657f01e6ba9a9ef8fd">◆ </a></span>retype() <span class="overload">[24/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__mem__functor7.html">bound_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__mem__functor7.html">bound_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="gadc01bb77132048902ec8965d012edcd3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gadc01bb77132048902ec8965d012edcd3">◆ </a></span>retype() <span class="overload">[25/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">bound_volatile_mem_functor0</a><T_return, T_obj> > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">bound_volatile_mem_functor0</a>< T_return, T_obj > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga45b921820c277072b6f7e856ddbcfca1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga45b921820c277072b6f7e856ddbcfca1">◆ </a></span>retype() <span class="overload">[26/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">bound_volatile_mem_functor1</a><T_return, T_obj, T_arg1>, T_arg1 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">bound_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="gaf420d79b4077b848ef1aef4b68810d6e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaf420d79b4077b848ef1aef4b68810d6e">◆ </a></span>retype() <span class="overload">[27/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">bound_volatile_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">bound_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga899ae79da0e918ad9fc8f2c8e8066218"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga899ae79da0e918ad9fc8f2c8e8066218">◆ </a></span>retype() <span class="overload">[28/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">bound_volatile_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">bound_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga8540037bfd4da57495b60dd9487c6d0b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga8540037bfd4da57495b60dd9487c6d0b">◆ </a></span>retype() <span class="overload">[29/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">bound_volatile_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1, T_arg2, T_arg3, T_arg4 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">bound_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga31ace8220cbb70b8e7f545ee4c1b6610"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga31ace8220cbb70b8e7f545ee4c1b6610">◆ </a></span>retype() <span class="overload">[30/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">bound_volatile_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">bound_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga9f45f05c95abc9d20ae9d39589f5d72e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga9f45f05c95abc9d20ae9d39589f5d72e">◆ </a></span>retype() <span class="overload">[31/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">bound_volatile_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">bound_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga17e8761db2fafa2d3a92d19d8ce47511"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga17e8761db2fafa2d3a92d19d8ce47511">◆ </a></span>retype() <span class="overload">[32/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">bound_volatile_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">bound_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::bound_volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga0688ca8eb3ee82e191563ba7f81366b2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga0688ca8eb3ee82e191563ba7f81366b2">◆ </a></span>retype() <span class="overload">[33/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1const__mem__functor0.html">const_mem_functor0</a><T_return, T_obj> > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1const__mem__functor0.html">const_mem_functor0</a>< T_return, T_obj > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::const_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="gae035134414ed79a187a6b41a115a3759"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gae035134414ed79a187a6b41a115a3759">◆ </a></span>retype() <span class="overload">[34/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1const__mem__functor1.html">const_mem_functor1</a><T_return, T_obj, T_arg1>, T_arg1 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1const__mem__functor1.html">const_mem_functor1</a>< T_return, T_obj, T_arg1 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::const_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga8e9ee582f601451f3aa7c3d37d03b952"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga8e9ee582f601451f3aa7c3d37d03b952">◆ </a></span>retype() <span class="overload">[35/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1const__mem__functor2.html">const_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1const__mem__functor2.html">const_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::const_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga81e06b857f7a44b0589125e28535f87f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga81e06b857f7a44b0589125e28535f87f">◆ </a></span>retype() <span class="overload">[36/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1const__mem__functor3.html">const_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1const__mem__functor3.html">const_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::const_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga411bdd3476f80d627c50d47149862ec2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga411bdd3476f80d627c50d47149862ec2">◆ </a></span>retype() <span class="overload">[37/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1const__mem__functor4.html">const_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1, T_arg2, T_arg3, T_arg4 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1const__mem__functor4.html">const_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::const_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga995053759ee8ee89663f9625a4aaf596"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga995053759ee8ee89663f9625a4aaf596">◆ </a></span>retype() <span class="overload">[38/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1const__mem__functor5.html">const_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1const__mem__functor5.html">const_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::const_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga851188153c54bb1eb8fee425f9796981"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga851188153c54bb1eb8fee425f9796981">◆ </a></span>retype() <span class="overload">[39/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1const__mem__functor6.html">const_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1const__mem__functor6.html">const_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::const_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="gaa951debcabd066f8c3479617aaa9689e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaa951debcabd066f8c3479617aaa9689e">◆ </a></span>retype() <span class="overload">[40/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1const__mem__functor7.html">const_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1const__mem__functor7.html">const_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::const_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga312fca59eb8b4ca0e078b1cf7f407212"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga312fca59eb8b4ca0e078b1cf7f407212">◆ </a></span>retype() <span class="overload">[41/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">const_volatile_mem_functor0</a><T_return, T_obj> > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">const_volatile_mem_functor0</a>< T_return, T_obj > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::const_volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga84f4247ab4cc559aed835ccd943fab70"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga84f4247ab4cc559aed835ccd943fab70">◆ </a></span>retype() <span class="overload">[42/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">const_volatile_mem_functor1</a><T_return, T_obj, T_arg1>, T_arg1 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">const_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::const_volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga271911579dfbac317a53f62f0773e420"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga271911579dfbac317a53f62f0773e420">◆ </a></span>retype() <span class="overload">[43/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">const_volatile_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">const_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::const_volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga97b4f14b5a7991eba60b635871d6a7f9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga97b4f14b5a7991eba60b635871d6a7f9">◆ </a></span>retype() <span class="overload">[44/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">const_volatile_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">const_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::const_volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga4e9179cc61db0069db209bc7632b3dee"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga4e9179cc61db0069db209bc7632b3dee">◆ </a></span>retype() <span class="overload">[45/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">const_volatile_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1, T_arg2, T_arg3, T_arg4 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">const_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::const_volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga637af7b3e60f5657dcd62e350ec76675"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga637af7b3e60f5657dcd62e350ec76675">◆ </a></span>retype() <span class="overload">[46/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">const_volatile_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">const_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::const_volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga17ceafe96cdf3bd37ccd401f413f8748"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga17ceafe96cdf3bd37ccd401f413f8748">◆ </a></span>retype() <span class="overload">[47/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">const_volatile_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">const_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::const_volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga75578233ce4f47c5f610569a5ffe84cc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga75578233ce4f47c5f610569a5ffe84cc">◆ </a></span>retype() <span class="overload">[48/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">const_volatile_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">const_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::const_volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="gabb08dd87f3ec392536b656b6b3e959a0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gabb08dd87f3ec392536b656b6b3e959a0">◆ </a></span>retype() <span class="overload">[49/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1mem__functor0.html">mem_functor0</a><T_return, T_obj> > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1mem__functor0.html">mem_functor0</a>< T_return, T_obj > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga5a2600190453d4eb11c14f99973044bc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga5a2600190453d4eb11c14f99973044bc">◆ </a></span>retype() <span class="overload">[50/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1mem__functor1.html">mem_functor1</a><T_return, T_obj, T_arg1>, T_arg1 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1mem__functor1.html">mem_functor1</a>< T_return, T_obj, T_arg1 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga7df338186f09b1c89c2840f6744362e9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga7df338186f09b1c89c2840f6744362e9">◆ </a></span>retype() <span class="overload">[51/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1mem__functor2.html">mem_functor2</a><T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1mem__functor2.html">mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="gae2d9d2e91b2f8d256e4ad8da1c3c59e0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gae2d9d2e91b2f8d256e4ad8da1c3c59e0">◆ </a></span>retype() <span class="overload">[52/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1mem__functor3.html">mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1mem__functor3.html">mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga70e615639e07e90a997a378cf877b106"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga70e615639e07e90a997a378cf877b106">◆ </a></span>retype() <span class="overload">[53/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1mem__functor4.html">mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1, T_arg2, T_arg3, T_arg4 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1mem__functor4.html">mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="gad225dee1d71c68d0ee71f3f0fedcfc1b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gad225dee1d71c68d0ee71f3f0fedcfc1b">◆ </a></span>retype() <span class="overload">[54/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1mem__functor5.html">mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1mem__functor5.html">mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga9c08fe50076854f15c923ab4183aed0f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga9c08fe50076854f15c923ab4183aed0f">◆ </a></span>retype() <span class="overload">[55/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1mem__functor6.html">mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1mem__functor6.html">mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga3fbd72b71a4ea4fafa487b5932acd797"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga3fbd72b71a4ea4fafa487b5932acd797">◆ </a></span>retype() <span class="overload">[56/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1mem__functor7.html">mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1mem__functor7.html">mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga23978c94d9d3c934803898c3bf48ff7d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga23978c94d9d3c934803898c3bf48ff7d">◆ </a></span>retype() <span class="overload">[57/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1pointer__functor0.html">pointer_functor0</a><T_return> > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1pointer__functor0.html">pointer_functor0</a>< T_return > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::pointer_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga75cc92c15faf06d5293ff34179f21899"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga75cc92c15faf06d5293ff34179f21899">◆ </a></span>retype() <span class="overload">[58/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1pointer__functor1.html">pointer_functor1</a><T_arg1, T_return>, T_arg1 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1pointer__functor1.html">pointer_functor1</a>< T_arg1, T_return > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::pointer_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga0d67e207b3d753ab71b3801981cfeff3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga0d67e207b3d753ab71b3801981cfeff3">◆ </a></span>retype() <span class="overload">[59/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1pointer__functor2.html">pointer_functor2</a><T_arg1, T_arg2, T_return>, T_arg1, T_arg2 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1pointer__functor2.html">pointer_functor2</a>< T_arg1, T_arg2, T_return > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::pointer_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="gaa5dfa926e3bfc7b82e0d14e4d9c9ff32"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaa5dfa926e3bfc7b82e0d14e4d9c9ff32">◆ </a></span>retype() <span class="overload">[60/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1pointer__functor3.html">pointer_functor3</a><T_arg1, T_arg2, T_arg3, T_return>, T_arg1, T_arg2, T_arg3 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1pointer__functor3.html">pointer_functor3</a>< T_arg1, T_arg2, T_arg3, T_return > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::pointer_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="gade02a3d76cf35465acfa39d4e03a40d5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gade02a3d76cf35465acfa39d4e03a40d5">◆ </a></span>retype() <span class="overload">[61/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1pointer__functor4.html">pointer_functor4</a><T_arg1, T_arg2, T_arg3, T_arg4, T_return>, T_arg1, T_arg2, T_arg3, T_arg4 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1pointer__functor4.html">pointer_functor4</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_return > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::pointer_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga45fa726d6497c6b0994444fd2569581c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga45fa726d6497c6b0994444fd2569581c">◆ </a></span>retype() <span class="overload">[62/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1pointer__functor5.html">pointer_functor5</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1pointer__functor5.html">pointer_functor5</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::pointer_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga24e30de09c3784220829f52bb068b8c0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga24e30de09c3784220829f52bb068b8c0">◆ </a></span>retype() <span class="overload">[63/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1pointer__functor6.html">pointer_functor6</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1pointer__functor6.html">pointer_functor6</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::pointer_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga09db0b458651a7fcd985e5dd4e50caa0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga09db0b458651a7fcd985e5dd4e50caa0">◆ </a></span>retype() <span class="overload">[64/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1pointer__functor7.html">pointer_functor7</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1pointer__functor7.html">pointer_functor7</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::pointer_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga8b98eeb2a61b5b1f84dcd1d20fe666f1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga8b98eeb2a61b5b1f84dcd1d20fe666f1">◆ </a></span>retype() <span class="overload">[65/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1slot.html">slot</a><T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a>.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga53d620659c82cbb84da3812ac874f4b7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga53d620659c82cbb84da3812ac874f4b7">◆ </a></span>retype() <span class="overload">[66/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1volatile__mem__functor0.html">volatile_mem_functor0</a><T_return, T_obj> > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1volatile__mem__functor0.html">volatile_mem_functor0</a>< T_return, T_obj > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga6d7f05b930056183bc7537447c80e59b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga6d7f05b930056183bc7537447c80e59b">◆ </a></span>retype() <span class="overload">[67/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1volatile__mem__functor1.html">volatile_mem_functor1</a><T_return, T_obj, T_arg1>, T_arg1 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1volatile__mem__functor1.html">volatile_mem_functor1</a>< T_return, T_obj, T_arg1 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga5b65e9a9794300c40b1577302e006fbd"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga5b65e9a9794300c40b1577302e006fbd">◆ </a></span>retype() <span class="overload">[68/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1volatile__mem__functor2.html">volatile_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1volatile__mem__functor2.html">volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga55236721b80a72f40453d1b939316635"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga55236721b80a72f40453d1b939316635">◆ </a></span>retype() <span class="overload">[69/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1volatile__mem__functor3.html">volatile_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1volatile__mem__functor3.html">volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga05d2c3c043bed420ba8ba6f40f42f692"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga05d2c3c043bed420ba8ba6f40f42f692">◆ </a></span>retype() <span class="overload">[70/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1volatile__mem__functor4.html">volatile_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1, T_arg2, T_arg3, T_arg4 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1volatile__mem__functor4.html">volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga42be2d2fbf03fbaba1ad7d8cbbb8bce4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga42be2d2fbf03fbaba1ad7d8cbbb8bce4">◆ </a></span>retype() <span class="overload">[71/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1volatile__mem__functor5.html">volatile_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1volatile__mem__functor5.html">volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga255fac4b456d69d033b327b1d533f054"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga255fac4b456d69d033b327b1d533f054">◆ </a></span>retype() <span class="overload">[72/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1volatile__mem__functor6.html">volatile_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1volatile__mem__functor6.html">volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga37a057f88e6ffbb8d4172d6446116796"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga37a057f88e6ffbb8d4172d6446116796">◆ </a></span>retype() <span class="overload">[73/73]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a><<a class="el" href="classsigc_1_1volatile__mem__functor7.html">volatile_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > sigc::retype </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1volatile__mem__functor7.html">volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. </p>
+<p>This function template specialization works on sigc::volatile_mem_functor.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing C-style casts on the paramters passed on. </dd></dl>
+
+</div>
+</div>
+<a id="ga23a8cdbc12c57fbef0866b5c51d71588"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga23a8cdbc12c57fbef0866b5c51d71588">◆ </a></span>retype_return()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__return__functor.html">retype_return_functor</a><T_return, T_functor> sigc::retype_return </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="structsigc_1_1retype__return__functor.html" title="Adaptor that performs a C-style cast on the return value of a functor.">sigc::retype_return_functor</a> which performs a C-style cast on the return value of the passed functor. </p>
+<p>The template argument <em>T_return</em> specifies the target type of the cast.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes <em>_A_functor</em> performing a C-style cast on the return value. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Functors</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#groups">Modules</a> |
+<a href="#nested-classes">Classes</a> |
+<a href="#define-members">Macros</a> |
+<a href="#func-members">Functions</a> </div>
+ <div class="headertitle">
+<div class="title">Functors</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Functors are copyable types that define operator()().
+<a href="#details">More...</a></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="groups"></a>
+Modules</h2></td></tr>
+<tr class="memitem:group__slot"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__slot.html">Slots</a></td></tr>
+<tr class="memdesc:group__slot"><td class="mdescLeft"> </td><td class="mdescRight">Slots are type-safe representations of callback methods and functions. <br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:group__mem__fun"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__mem__fun.html">mem_fun()</a></td></tr>
+<tr class="memdesc:group__mem__fun"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> Creates a functor from a pointer to a method. <br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:group__ptr__fun"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html">ptr_fun()</a></td></tr>
+<tr class="memdesc:group__ptr__fun"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863" title="Creates a functor of type sigc::pointer_functor0 which wraps an existing non-member function.">ptr_fun()</a> is used to convert a pointer to a function to a functor. <br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Classes</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1can__deduce__result__type__with__decltype.html">sigc::can_deduce_result_type_with_decltype< T_functor ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Helper class, to determine if decltype() can deduce the result type of a functor. <a href="classsigc_1_1can__deduce__result__type__with__decltype.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1functor__base.html">sigc::functor_base</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">A hint to the compiler. <a href="structsigc_1_1functor__base.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1functor__trait.html">sigc::functor_trait< T_functor, I_derives_functor_base, I_can_use_decltype ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Trait that specifies the return type of any type. <a href="structsigc_1_1functor__trait.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1visitor.html">sigc::visitor< T_functor ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="structsigc_1_1visitor.html#a9fe5d6be845e622a99a0db5d3621d4b3">sigc::visitor<T_functor>::do_visit_each()</a> performs a functor on each of the targets of a functor. <a href="structsigc_1_1visitor.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="define-members"></a>
+Macros</h2></td></tr>
+<tr class="memitem:ga7a6f5575dc0b0ea896889c782721f6be"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__sigcfunctors.html#ga7a6f5575dc0b0ea896889c782721f6be">SIGC_FUNCTOR_TRAIT</a>(T_functor, T_return)</td></tr>
+<tr class="memdesc:ga7a6f5575dc0b0ea896889c782721f6be"><td class="mdescLeft"> </td><td class="mdescRight">Helper macro, if you want to mix user-defined and third party functors with libsigc++. <a href="group__sigcfunctors.html#ga7a6f5575dc0b0ea896889c782721f6be">More...</a><br /></td></tr>
+<tr class="separator:ga7a6f5575dc0b0ea896889c782721f6be"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gadf1ba3cacb09cc5c3c3e399836ec6e50"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__sigcfunctors.html#gadf1ba3cacb09cc5c3c3e399836ec6e50">SIGC_FUNCTORS_DEDUCE_RESULT_TYPE_WITH_DECLTYPE</a></td></tr>
+<tr class="memdesc:gadf1ba3cacb09cc5c3c3e399836ec6e50"><td class="mdescLeft"> </td><td class="mdescRight">Helper macro, if you want to mix user-defined and third party functors with libsigc++. <a href="group__sigcfunctors.html#gadf1ba3cacb09cc5c3c3e399836ec6e50">More...</a><br /></td></tr>
+<tr class="separator:gadf1ba3cacb09cc5c3c3e399836ec6e50"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga93b6ee8815d90adccfdceed72bcda577"><td class="memItemLeft" align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="group__sigcfunctors.html#ga93b6ee8815d90adccfdceed72bcda577">SIGC_FUNCTORS_HAVE_RESULT_TYPE</a></td></tr>
+<tr class="memdesc:ga93b6ee8815d90adccfdceed72bcda577"><td class="mdescLeft"> </td><td class="mdescRight">Helper macro, if you want to mix user-defined and third party functors with libsigc++. <a href="group__sigcfunctors.html#ga93b6ee8815d90adccfdceed72bcda577">More...</a><br /></td></tr>
+<tr class="separator:ga93b6ee8815d90adccfdceed72bcda577"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
+Functions</h2></td></tr>
+<tr class="memitem:ga64cb7832acc1e58efb5ffe0b4f5e9404"><td class="memTemplParams" colspan="2">template<class T_action , class T_functor > </td></tr>
+<tr class="memitem:ga64cb7832acc1e58efb5ffe0b4f5e9404"><td class="memTemplItemLeft" align="right" valign="top">void </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404">sigc::visit_each</a> (const T_action & _A_action, const T_functor & _A_functor)</td></tr>
+<tr class="memdesc:ga64cb7832acc1e58efb5ffe0b4f5e9404"><td class="mdescLeft"> </td><td class="mdescRight">This function performs a functor on each of the targets of a functor. <a href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404">More...</a><br /></td></tr>
+<tr class="separator:ga64cb7832acc1e58efb5ffe0b4f5e9404"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gada222d975b87d64cfa7a7f29244ae587"><td class="memTemplParams" colspan="2">template<class T_type , class T_action , class T_functor > </td></tr>
+<tr class="memitem:gada222d975b87d64cfa7a7f29244ae587"><td class="memTemplItemLeft" align="right" valign="top">void </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__sigcfunctors.html#gada222d975b87d64cfa7a7f29244ae587">sigc::visit_each_type</a> (const T_action & _A_action, const T_functor & _A_functor)</td></tr>
+<tr class="memdesc:gada222d975b87d64cfa7a7f29244ae587"><td class="mdescLeft"> </td><td class="mdescRight">This function performs a functor on each of the targets of a functor limited to a restricted type. <a href="group__sigcfunctors.html#gada222d975b87d64cfa7a7f29244ae587">More...</a><br /></td></tr>
+<tr class="separator:gada222d975b87d64cfa7a7f29244ae587"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<p>Functors are copyable types that define operator()(). </p>
+<p>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++.</p>
+<p>Closures are functors that store all information needed to invoke a callback from operator()().</p>
+<p>Adaptors are functors that alter the signature of a functor's operator()().</p>
+<p>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.</p>
+<p>The basic functor types libsigc++ provides are created with <a class="el" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863" title="Creates a functor of type sigc::pointer_functor0 which wraps an existing non-member function.">ptr_fun()</a> and <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">mem_fun()</a> and can be converted into slots implicitly. The set of adaptors that ships with libsigc++ is documented in the <a class="el" href="group__adaptors.html">Adaptors</a> module.</p>
+<p>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.</p>
+<ul>
+<li>Derive your functors from <a class="el" href="structsigc_1_1functor__base.html" title="A hint to the compiler.">sigc::functor_base</a> and place <code>typedef T_return result_type;</code> in the class definition.</li>
+<li>Use the macro <a class="el" href="group__sigcfunctors.html#ga7a6f5575dc0b0ea896889c782721f6be" title="Helper macro, if you want to mix user-defined and third party functors with libsigc++.">SIGC_FUNCTOR_TRAIT(T_functor,T_return)</a> in namespace sigc. Multi-type functors are only partly supported.</li>
+<li>For functors not derived from <a class="el" href="structsigc_1_1functor__base.html" title="A hint to the compiler.">sigc::functor_base</a>, and not specified with <a class="el" href="group__sigcfunctors.html#ga7a6f5575dc0b0ea896889c782721f6be" title="Helper macro, if you want to mix user-defined and third party functors with libsigc++.">SIGC_FUNCTOR_TRAIT()</a>, 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.</li>
+<li>Use the macro <a class="el" href="group__sigcfunctors.html#ga93b6ee8815d90adccfdceed72bcda577" title="Helper macro, if you want to mix user-defined and third party functors with libsigc++.">SIGC_FUNCTORS_HAVE_RESULT_TYPE</a>, 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.</li>
+</ul>
+<p>If all these ways to deduce the result type fail, void is assumed.</p>
+<p>With libsigc++ versions before 2.6, the macro <a class="el" href="group__sigcfunctors.html#gadf1ba3cacb09cc5c3c3e399836ec6e50" title="Helper macro, if you want to mix user-defined and third party functors with libsigc++.">SIGC_FUNCTORS_DEDUCE_RESULT_TYPE_WITH_DECLTYPE</a> activated the test with decltype(). That macro is now unneccesary and deprecated. </p>
+<h2 class="groupheader">Macro Definition Documentation</h2>
+<a id="ga7a6f5575dc0b0ea896889c782721f6be"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga7a6f5575dc0b0ea896889c782721f6be">◆ </a></span>SIGC_FUNCTOR_TRAIT</h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname">#define SIGC_FUNCTOR_TRAIT</td>
+ <td>(</td>
+ <td class="paramtype"> </td>
+ <td class="paramname">T_functor, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"> </td>
+ <td class="paramname">T_return </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+<p>Helper macro, if you want to mix user-defined and third party functors with libsigc++. </p>
+<p>If you want to mix functors not derived from <a class="el" href="structsigc_1_1functor__base.html" title="A hint to the compiler.">sigc::functor_base</a> with libsigc++, and these functors don't define <code>result_type</code>, use this macro inside namespace sigc to expose the return type of the functors like so: </p><div class="fragment"><div class="line"><span class="keyword">namespace </span><a class="code" href="namespacesigc.html">sigc</a> {</div>
+<div class="line"> <a class="code" href="group__sigcfunctors.html#ga7a6f5575dc0b0ea896889c782721f6be">SIGC_FUNCTOR_TRAIT</a>(first_functor_type, return_type_of_first_functor_type)</div>
+<div class="line"> <a class="code" href="group__sigcfunctors.html#ga7a6f5575dc0b0ea896889c782721f6be">SIGC_FUNCTOR_TRAIT</a>(second_functor_type, return_type_of_second_functor_type)</div>
+<div class="line"> ...</div>
+<div class="line">}</div>
+<div class="ttc" id="agroup__sigcfunctors_html_ga7a6f5575dc0b0ea896889c782721f6be"><div class="ttname"><a href="group__sigcfunctors.html#ga7a6f5575dc0b0ea896889c782721f6be">SIGC_FUNCTOR_TRAIT</a></div><div class="ttdeci">#define SIGC_FUNCTOR_TRAIT(T_functor, T_return)</div><div class="ttdoc">Helper macro, if you want to mix user-defined and third party functors with libsigc++.</div><div class="ttdef"><b>Definition:</b> functor_trait.h:188</div></div>
+<div class="ttc" id="anamespacesigc_html"><div class="ttname"><a href="namespacesigc.html">sigc</a></div><div class="ttdoc">The libsigc++ namespace.</div><div class="ttdef"><b>Definition:</b> limit_reference.h:12</div></div>
+</div><!-- fragment -->
+</div>
+</div>
+<a id="gadf1ba3cacb09cc5c3c3e399836ec6e50"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gadf1ba3cacb09cc5c3c3e399836ec6e50">◆ </a></span>SIGC_FUNCTORS_DEDUCE_RESULT_TYPE_WITH_DECLTYPE</h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname">#define SIGC_FUNCTORS_DEDUCE_RESULT_TYPE_WITH_DECLTYPE</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+<p>Helper macro, if you want to mix user-defined and third party functors with libsigc++. </p>
+<p>If you want to mix functors not derived from <a class="el" href="structsigc_1_1functor__base.html" title="A hint to the compiler.">sigc::functor_base</a> with libsigc++, and your compiler can deduce the result type of the functor with the C++11 keyword <code>decltype</code>, use this macro inside namespace sigc like so: </p><div class="fragment"><div class="line"><span class="keyword">namespace </span><a class="code" href="namespacesigc.html">sigc</a> {</div>
+<div class="line"> <a class="code" href="group__sigcfunctors.html#gadf1ba3cacb09cc5c3c3e399836ec6e50">SIGC_FUNCTORS_DEDUCE_RESULT_TYPE_WITH_DECLTYPE</a></div>
+<div class="line">}</div>
+<div class="ttc" id="agroup__sigcfunctors_html_gadf1ba3cacb09cc5c3c3e399836ec6e50"><div class="ttname"><a href="group__sigcfunctors.html#gadf1ba3cacb09cc5c3c3e399836ec6e50">SIGC_FUNCTORS_DEDUCE_RESULT_TYPE_WITH_DECLTYPE</a></div><div class="ttdeci">#define SIGC_FUNCTORS_DEDUCE_RESULT_TYPE_WITH_DECLTYPE</div><div class="ttdoc">Helper macro, if you want to mix user-defined and third party functors with libsigc++.</div><div class="ttdef"><b>Definition:</b> functor_trait.h:223</div></div>
+</div><!-- fragment --><p>Functors with overloaded operator()() are not supported.</p>
+<dl class="since_2_2_11"><dt><b><a class="el" href="since_2_2_11.html#_since_2_2_11000001">Since libsigc++ 2.2.11:</a></b></dt><dd></dd></dl>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000065">Deprecated:</a></b></dt><dd>This macro does nothing. The test it activated in libsigc++ versions before 2.6, is now unconditionally activated.</dd></dl>
+
+</div>
+</div>
+<a id="ga93b6ee8815d90adccfdceed72bcda577"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga93b6ee8815d90adccfdceed72bcda577">◆ </a></span>SIGC_FUNCTORS_HAVE_RESULT_TYPE</h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname">#define SIGC_FUNCTORS_HAVE_RESULT_TYPE</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+<p>Helper macro, if you want to mix user-defined and third party functors with libsigc++. </p>
+<p>If you want to mix functors not derived from <a class="el" href="structsigc_1_1functor__base.html" title="A hint to the compiler.">sigc::functor_base</a> with libsigc++, and these functors define <code>result_type</code>, use this macro inside namespace sigc like so: </p><div class="fragment"><div class="line"><span class="keyword">namespace </span><a class="code" href="namespacesigc.html">sigc</a> { <a class="code" href="group__sigcfunctors.html#ga93b6ee8815d90adccfdceed72bcda577">SIGC_FUNCTORS_HAVE_RESULT_TYPE</a> }</div>
+<div class="ttc" id="agroup__sigcfunctors_html_ga93b6ee8815d90adccfdceed72bcda577"><div class="ttname"><a href="group__sigcfunctors.html#ga93b6ee8815d90adccfdceed72bcda577">SIGC_FUNCTORS_HAVE_RESULT_TYPE</a></div><div class="ttdeci">#define SIGC_FUNCTORS_HAVE_RESULT_TYPE</div><div class="ttdoc">Helper macro, if you want to mix user-defined and third party functors with libsigc++.</div><div class="ttdef"><b>Definition:</b> functor_trait.h:165</div></div>
+</div><!-- fragment -->
+</div>
+</div>
+<h2 class="groupheader">Function Documentation</h2>
+<a id="ga64cb7832acc1e58efb5ffe0b4f5e9404"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga64cb7832acc1e58efb5ffe0b4f5e9404">◆ </a></span>visit_each()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_action , class T_functor > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">void sigc::visit_each </td>
+ <td>(</td>
+ <td class="paramtype">const T_action & </td>
+ <td class="paramname"><em>_A_action</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_functor</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+<p>This function performs a functor on each of the targets of a functor. </p>
+
+</div>
+</div>
+<a id="gada222d975b87d64cfa7a7f29244ae587"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gada222d975b87d64cfa7a7f29244ae587">◆ </a></span>visit_each_type()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type , class T_action , class T_functor > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">void sigc::visit_each_type </td>
+ <td>(</td>
+ <td class="paramtype">const T_action & </td>
+ <td class="paramname"><em>_A_action</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_functor</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+<p>This function performs a functor on each of the targets of a functor limited to a restricted type. </p>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Signals</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#nested-classes">Classes</a> </div>
+ <div class="headertitle">
+<div class="title">Signals</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Use <a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2" title="Add a slot to the list of slots.">sigc::signal::connect()</a> with <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">sigc::mem_fun()</a> and <a class="el" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863" title="Creates a functor of type sigc::pointer_functor0 which wraps an existing non-member function.">sigc::ptr_fun()</a> to connect a method or function with a signal.
+<a href="#details">More...</a></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Classes</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1connection.html">sigc::connection</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convinience class for safe disconnection. <a href="structsigc_1_1connection.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1nil.html">sigc::nil</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">nil struct type. <a href="structsigc_1_1nil.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates. <a href="classsigc_1_1signal.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html">sigc::signal0< T_return, T_accumulator ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Signal declaration. <a href="classsigc_1_1signal0.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Signal declaration. <a href="classsigc_1_1signal1.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Signal declaration. <a href="classsigc_1_1signal2.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Signal declaration. <a href="classsigc_1_1signal3.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Signal declaration. <a href="classsigc_1_1signal4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Signal declaration. <a href="classsigc_1_1signal5.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Signal declaration. <a href="classsigc_1_1signal6.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Signal declaration. <a href="classsigc_1_1signal7.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_1_1accumulated.html">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::accumulated< T_accumulator ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates. <a href="classsigc_1_1signal_1_1accumulated.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::accumulated< T_accumulator ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates. <a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Base class for the <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates. <a href="structsigc_1_1signal__base.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator< T_slot ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">STL-style const iterator for <a class="el" href="structsigc_1_1slot__list.html" title="STL-style list interface for sigc::signal#.">slot_list</a>. <a href="structsigc_1_1slot__const__iterator.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator< T_slot ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">STL-style iterator for <a class="el" href="structsigc_1_1slot__list.html" title="STL-style list interface for sigc::signal#.">slot_list</a>. <a href="structsigc_1_1slot__iterator.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">STL-style list interface for <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a>#. <a href="structsigc_1_1slot__list.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Base class for objects with auto-disconnection. <a href="structsigc_1_1trackable.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<p>Use <a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2" title="Add a slot to the list of slots.">sigc::signal::connect()</a> with <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">sigc::mem_fun()</a> and <a class="el" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863" title="Creates a functor of type sigc::pointer_functor0 which wraps an existing non-member function.">sigc::ptr_fun()</a> to connect a method or function with a signal. </p>
+<div class="fragment"><div class="line">signal_clicked.connect( <a class="code" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">sigc::mem_fun</a>(*<span class="keyword">this</span>, &MyWindow::on_clicked) );</div>
+<div class="ttc" id="agroup__mem__fun_html_gadf6b6d22c503b439019f0a2e77352419"><div class="ttname"><a href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">sigc::mem_fun</a></div><div class="ttdeci">mem_functor0< T_return, T_obj > mem_fun(T_return(T_obj::*_A_func)())</div><div class="ttdoc">Creates a functor of type sigc::mem_functor0 which wraps a method.</div><div class="ttdef"><b>Definition:</b> mem_fun.h:5797</div></div>
+</div><!-- fragment --><p>When the signal is emitted your method will be called.</p>
+<p><a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2" title="Add a slot to the list of slots.">signal::connect()</a> returns a connection, which you can later use to disconnect your method. If the type of your object inherits from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> the method is disconnected automatically when your object is destroyed.</p>
+<p>When signals are copied they share the underlying information, so you can have a protected/private <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> member and a public accessor method. A <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> is a kind of reference-counting pointer. It's similar to std::shared_ptr<>, although <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> is restricted to holding a pointer to a sigc::internal::signal_impl object that contains the implementation of the signal.</p>
+<div class="fragment"><div class="line"><span class="keyword">class </span>MyClass</div>
+<div class="line">{</div>
+<div class="line"><span class="keyword">public</span>:</div>
+<div class="line"> <span class="keyword">typedef</span> <a class="code" href="classsigc_1_1signal.html">sigc::signal<void></a> MySignalType;</div>
+<div class="line"> MySignalType get_my_signal() { <span class="keywordflow">return</span> m_my_signal; }</div>
+<div class="line"><span class="keyword">private</span>:</div>
+<div class="line"> MySignalType m_my_signal;</div>
+<div class="line">};</div>
+<div class="ttc" id="aclasssigc_1_1signal_html"><div class="ttname"><a href="classsigc_1_1signal.html">sigc::signal</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::signal# templates.</div><div class="ttdef"><b>Definition:</b> signal.h:4015</div></div>
+</div><!-- fragment --><p>signal and slot objects provide the core functionality of this library. A slot is a container for an arbitrary functor. A signal is a list of slots that are executed on emission. For compile time type safety a list of template arguments must be provided for the signal template that determines the parameter list for emission. Functors and closures are converted into slots implicitly on connection, triggering compiler errors if the given functor or closure cannot be invoked with the parameter list of the signal to connect to.</p>
+<p>Almost any functor with the correct signature can be converted to a <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> and connected to a signal. See <a class="el" href="group__slot.html">Slots</a> and <a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2" title="Add a slot to the list of slots.">sigc::signal::connect()</a>. </p>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Slots</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#nested-classes">Classes</a> </div>
+ <div class="headertitle">
+<div class="title">Slots<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Slots are type-safe representations of callback methods and functions.
+<a href="#details">More...</a></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Classes</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1nil.html">sigc::nil</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">nil struct type. <a href="structsigc_1_1nil.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot.html">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a># templates. <a href="classsigc_1_1slot.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot0.html">sigc::slot0< T_return ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Converts an arbitrary functor to a unified type which is opaque. <a href="classsigc_1_1slot0.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot1.html">sigc::slot1< T_return, T_arg1 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Converts an arbitrary functor to a unified type which is opaque. <a href="classsigc_1_1slot1.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot2.html">sigc::slot2< T_return, T_arg1, T_arg2 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Converts an arbitrary functor to a unified type which is opaque. <a href="classsigc_1_1slot2.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot3.html">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Converts an arbitrary functor to a unified type which is opaque. <a href="classsigc_1_1slot3.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot4.html">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Converts an arbitrary functor to a unified type which is opaque. <a href="classsigc_1_1slot4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot5.html">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Converts an arbitrary functor to a unified type which is opaque. <a href="classsigc_1_1slot5.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Converts an arbitrary functor to a unified type which is opaque. <a href="classsigc_1_1slot6.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Converts an arbitrary functor to a unified type which is opaque. <a href="classsigc_1_1slot7.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html">sigc::slot< T_return(T_arg...)></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Converts an arbitrary functor to a unified type which is opaque. <a href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html">sigc::slot_base</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Base type for slots. <a href="classsigc_1_1slot__base.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<p>Slots are type-safe representations of callback methods and functions. </p>
+<p>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.</p>
+<h1><a class="anchor" id="slots-creating"></a>
+Creating Slots</h1>
+<p>Use the <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">sigc::mem_fun()</a> or <a class="el" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863" title="Creates a functor of type sigc::pointer_functor0 which wraps an existing non-member function.">sigc::ptr_fun()</a> template functions to get a <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a>, like so: </p><div class="fragment"><div class="line"><a class="code" href="classsigc_1_1slot.html">sigc::slot<void, int></a> sl = <a class="code" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">sigc::mem_fun</a>(someobj, & SomeClass::somemethod);</div>
+<div class="ttc" id="aclasssigc_1_1slot_html"><div class="ttname"><a href="classsigc_1_1slot.html">sigc::slot</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::slot# templates.</div><div class="ttdef"><b>Definition:</b> slot.h:1645</div></div>
+<div class="ttc" id="agroup__mem__fun_html_gadf6b6d22c503b439019f0a2e77352419"><div class="ttname"><a href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">sigc::mem_fun</a></div><div class="ttdeci">mem_functor0< T_return, T_obj > mem_fun(T_return(T_obj::*_A_func)())</div><div class="ttdoc">Creates a functor of type sigc::mem_functor0 which wraps a method.</div><div class="ttdef"><b>Definition:</b> mem_fun.h:5797</div></div>
+</div><!-- fragment --><p> or </p><div class="fragment"><div class="line"><a class="code" href="classsigc_1_1slot.html">sigc::slot<void, int></a> sl = <a class="code" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863">sigc::ptr_fun</a>(&somefunction);</div>
+<div class="ttc" id="agroup__ptr__fun_html_ga9c80de72f656fb05e81fda622dddc863"><div class="ttname"><a href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863">sigc::ptr_fun</a></div><div class="ttdeci">pointer_functor0< T_return > ptr_fun(T_return(*_A_func)())</div><div class="ttdoc">Creates a functor of type sigc::pointer_functor0 which wraps an existing non-member function.</div><div class="ttdef"><b>Definition:</b> ptr_fun.h:460</div></div>
+</div><!-- fragment --><p> or, in gtkmm, </p><div class="fragment"><div class="line">m_Button.signal_clicked().connect( <a class="code" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">sigc::mem_fun</a>(*<span class="keyword">this</span>, &MyWindow::on_button_clicked) );</div>
+</div><!-- fragment --><p>The compiler will complain if SomeClass::somemethod, etc. have the wrong signature.</p>
+<p>You can also pass slots as method parameters where you might normally pass a function pointer.</p>
+<h1><a class="anchor" id="slots-auto-disconnect"></a>
+Member Methods and Automatic Disconnection</h1>
+<p>See <a class="el" href="group__mem__fun.html">sigc::mem_fun()</a> about deriving from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> to prevent member methods from being called after the instance has been destroyed.</p>
+<h1><a class="anchor" id="slots-auto"></a>
+auto</h1>
+<p><a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">sigc::mem_fun()</a> and <a class="el" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863" title="Creates a functor of type sigc::pointer_functor0 which wraps an existing non-member function.">sigc::ptr_fun()</a> return functors, but those functors are not slots. </p><div class="fragment"><div class="line"><a class="code" href="classsigc_1_1slot.html">sigc::slot<void, int></a> sl = <a class="code" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">sigc::mem_fun</a>(someobj, & SomeClass::somemethod);</div>
+</div><!-- fragment --><p> is not equivalent to </p><div class="fragment"><div class="line"><span class="keyword">auto</span> sl = <a class="code" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">sigc::mem_fun</a>(someobj, &SomeClass::somemethod); <span class="comment">// Not a slot!</span></div>
+</div><!-- fragment --><p>If you don't explicitly use a <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> 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 <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>.</p>
+<h1><a class="anchor" id="slots-with-lambdas"></a>
+C++ Lambdas</h1>
+<p>A C++11 lambda expression is a functor (function object). It is automatically wrapped in a slot, if it is connected to a signal. </p><div class="fragment"><div class="line"><span class="keyword">auto</span> on_response = [&someobj] (<span class="keywordtype">int</span> response_id)</div>
+<div class="line"> {</div>
+<div class="line"> someobj.somemethod(response_id);</div>
+<div class="line"> somefunction(response_id);</div>
+<div class="line"> };</div>
+<div class="line">m_Dialog.signal_response().connect(on_response);</div>
+</div><!-- fragment --><p>If you connect a C++11 lambda expression or a std::function<> instance to a signal or assign it to a slot,</p><ul>
+<li>With libsigc++ versions before 2.6, if the return type is not void, you must use the <a class="el" href="group__sigcfunctors.html#gadf1ba3cacb09cc5c3c3e399836ec6e50" title="Helper macro, if you want to mix user-defined and third party functors with libsigc++.">SIGC_FUNCTORS_DEDUCE_RESULT_TYPE_WITH_DECLTYPE</a> macro,</li>
+<li>if your functor contains references to <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> derived objects, those objects will not be tracked, unless you also use <a class="el" href="group__track__obj.html#ga8fd1ab36d123ff83dd4cd8dc58bb28e2" title="Creates an adaptor of type sigc::track_obj_functor1 which wraps a functor.">sigc::track_obj()</a>. </li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: track_obj()</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#nested-classes">Classes</a> |
+<a href="#func-members">Functions</a> </div>
+ <div class="headertitle">
+<div class="title">track_obj()<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="group__track__obj.html#ga8fd1ab36d123ff83dd4cd8dc58bb28e2" title="Creates an adaptor of type sigc::track_obj_functor1 which wraps a functor.">sigc::track_obj()</a> tracks trackable objects, referenced from a functor.
+<a href="#details">More...</a></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Classes</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object.">track_obj_functor1</a> wraps a functor and stores a reference to a trackable object. <a href="classsigc_1_1track__obj__functor1.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor2.html">sigc::track_obj_functor2< T_functor, T_obj1, T_obj2 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1track__obj__functor2.html" title="track_obj_functor2 wraps a functor and stores 2 references to trackable objects.">track_obj_functor2</a> wraps a functor and stores 2 references to trackable objects. <a href="classsigc_1_1track__obj__functor2.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor3.html">sigc::track_obj_functor3< T_functor, T_obj1, T_obj2, T_obj3 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1track__obj__functor3.html" title="track_obj_functor3 wraps a functor and stores 3 references to trackable objects.">track_obj_functor3</a> wraps a functor and stores 3 references to trackable objects. <a href="classsigc_1_1track__obj__functor3.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor4.html">sigc::track_obj_functor4< T_functor, T_obj1, T_obj2, T_obj3, T_obj4 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1track__obj__functor4.html" title="track_obj_functor4 wraps a functor and stores 4 references to trackable objects.">track_obj_functor4</a> wraps a functor and stores 4 references to trackable objects. <a href="classsigc_1_1track__obj__functor4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor5.html">sigc::track_obj_functor5< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1track__obj__functor5.html" title="track_obj_functor5 wraps a functor and stores 5 references to trackable objects.">track_obj_functor5</a> wraps a functor and stores 5 references to trackable objects. <a href="classsigc_1_1track__obj__functor5.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor6.html">sigc::track_obj_functor6< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1track__obj__functor6.html" title="track_obj_functor6 wraps a functor and stores 6 references to trackable objects.">track_obj_functor6</a> wraps a functor and stores 6 references to trackable objects. <a href="classsigc_1_1track__obj__functor6.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor7.html">sigc::track_obj_functor7< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6, T_obj7 ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1track__obj__functor7.html" title="track_obj_functor7 wraps a functor and stores 7 references to trackable objects.">track_obj_functor7</a> wraps a functor and stores 7 references to trackable objects. <a href="classsigc_1_1track__obj__functor7.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
+Functions</h2></td></tr>
+<tr class="memitem:ga8fd1ab36d123ff83dd4cd8dc58bb28e2"><td class="memTemplParams" colspan="2">template<typename T_functor , typename T_obj1 > </td></tr>
+<tr class="memitem:ga8fd1ab36d123ff83dd4cd8dc58bb28e2"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1track__obj__functor1.html">track_obj_functor1</a>< T_functor, T_obj1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__track__obj.html#ga8fd1ab36d123ff83dd4cd8dc58bb28e2">sigc::track_obj</a> (const T_functor & _A_func, const T_obj1 & _A_obj1)</td></tr>
+<tr class="memdesc:ga8fd1ab36d123ff83dd4cd8dc58bb28e2"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object.">sigc::track_obj_functor1</a> which wraps a functor. <a href="group__track__obj.html#ga8fd1ab36d123ff83dd4cd8dc58bb28e2">More...</a><br /></td></tr>
+<tr class="separator:ga8fd1ab36d123ff83dd4cd8dc58bb28e2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga60842510c2387ec49c43149d94fb1b72"><td class="memTemplParams" colspan="2">template<typename T_functor , typename T_obj1 , typename T_obj2 > </td></tr>
+<tr class="memitem:ga60842510c2387ec49c43149d94fb1b72"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1track__obj__functor2.html">track_obj_functor2</a>< T_functor, T_obj1, T_obj2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__track__obj.html#ga60842510c2387ec49c43149d94fb1b72">sigc::track_obj</a> (const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2)</td></tr>
+<tr class="memdesc:ga60842510c2387ec49c43149d94fb1b72"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="classsigc_1_1track__obj__functor2.html" title="track_obj_functor2 wraps a functor and stores 2 references to trackable objects.">sigc::track_obj_functor2</a> which wraps a functor. <a href="group__track__obj.html#ga60842510c2387ec49c43149d94fb1b72">More...</a><br /></td></tr>
+<tr class="separator:ga60842510c2387ec49c43149d94fb1b72"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga52b11304cb05441237a8dcc651cb724e"><td class="memTemplParams" colspan="2">template<typename T_functor , typename T_obj1 , typename T_obj2 , typename T_obj3 > </td></tr>
+<tr class="memitem:ga52b11304cb05441237a8dcc651cb724e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1track__obj__functor3.html">track_obj_functor3</a>< T_functor, T_obj1, T_obj2, T_obj3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__track__obj.html#ga52b11304cb05441237a8dcc651cb724e">sigc::track_obj</a> (const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2, const T_obj3 & _A_obj3)</td></tr>
+<tr class="memdesc:ga52b11304cb05441237a8dcc651cb724e"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="classsigc_1_1track__obj__functor3.html" title="track_obj_functor3 wraps a functor and stores 3 references to trackable objects.">sigc::track_obj_functor3</a> which wraps a functor. <a href="group__track__obj.html#ga52b11304cb05441237a8dcc651cb724e">More...</a><br /></td></tr>
+<tr class="separator:ga52b11304cb05441237a8dcc651cb724e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaea44f2388c18ca8508818ff6b7756216"><td class="memTemplParams" colspan="2">template<typename T_functor , typename T_obj1 , typename T_obj2 , typename T_obj3 , typename T_obj4 > </td></tr>
+<tr class="memitem:gaea44f2388c18ca8508818ff6b7756216"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1track__obj__functor4.html">track_obj_functor4</a>< T_functor, T_obj1, T_obj2, T_obj3, T_obj4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__track__obj.html#gaea44f2388c18ca8508818ff6b7756216">sigc::track_obj</a> (const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2, const T_obj3 & _A_obj3, const T_obj4 & _A_obj4)</td></tr>
+<tr class="memdesc:gaea44f2388c18ca8508818ff6b7756216"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="classsigc_1_1track__obj__functor4.html" title="track_obj_functor4 wraps a functor and stores 4 references to trackable objects.">sigc::track_obj_functor4</a> which wraps a functor. <a href="group__track__obj.html#gaea44f2388c18ca8508818ff6b7756216">More...</a><br /></td></tr>
+<tr class="separator:gaea44f2388c18ca8508818ff6b7756216"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga337dc48ba1e394f572d5d914b83f57a0"><td class="memTemplParams" colspan="2">template<typename T_functor , typename T_obj1 , typename T_obj2 , typename T_obj3 , typename T_obj4 , typename T_obj5 > </td></tr>
+<tr class="memitem:ga337dc48ba1e394f572d5d914b83f57a0"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1track__obj__functor5.html">track_obj_functor5</a>< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__track__obj.html#ga337dc48ba1e394f572d5d914b83f57a0">sigc::track_obj</a> (const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2, const T_obj3 & _A_obj3, const T_obj4 & _A_obj4, const T_obj5 & _A_obj5)</td></tr>
+<tr class="memdesc:ga337dc48ba1e394f572d5d914b83f57a0"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="classsigc_1_1track__obj__functor5.html" title="track_obj_functor5 wraps a functor and stores 5 references to trackable objects.">sigc::track_obj_functor5</a> which wraps a functor. <a href="group__track__obj.html#ga337dc48ba1e394f572d5d914b83f57a0">More...</a><br /></td></tr>
+<tr class="separator:ga337dc48ba1e394f572d5d914b83f57a0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga0304ca1269ed352fcc1c81324062302e"><td class="memTemplParams" colspan="2">template<typename T_functor , typename T_obj1 , typename T_obj2 , typename T_obj3 , typename T_obj4 , typename T_obj5 , typename T_obj6 > </td></tr>
+<tr class="memitem:ga0304ca1269ed352fcc1c81324062302e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1track__obj__functor6.html">track_obj_functor6</a>< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__track__obj.html#ga0304ca1269ed352fcc1c81324062302e">sigc::track_obj</a> (const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2, const T_obj3 & _A_obj3, const T_obj4 & _A_obj4, const T_obj5 & _A_obj5, const T_obj6 & _A_obj6)</td></tr>
+<tr class="memdesc:ga0304ca1269ed352fcc1c81324062302e"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="classsigc_1_1track__obj__functor6.html" title="track_obj_functor6 wraps a functor and stores 6 references to trackable objects.">sigc::track_obj_functor6</a> which wraps a functor. <a href="group__track__obj.html#ga0304ca1269ed352fcc1c81324062302e">More...</a><br /></td></tr>
+<tr class="separator:ga0304ca1269ed352fcc1c81324062302e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga5ea3e9f52643d7ab1bcfa4f419e7d38f"><td class="memTemplParams" colspan="2">template<typename T_functor , typename T_obj1 , typename T_obj2 , typename T_obj3 , typename T_obj4 , typename T_obj5 , typename T_obj6 , typename T_obj7 > </td></tr>
+<tr class="memitem:ga5ea3e9f52643d7ab1bcfa4f419e7d38f"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1track__obj__functor7.html">track_obj_functor7</a>< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6, T_obj7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__track__obj.html#ga5ea3e9f52643d7ab1bcfa4f419e7d38f">sigc::track_obj</a> (const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2, const T_obj3 & _A_obj3, const T_obj4 & _A_obj4, const T_obj5 & _A_obj5, const T_obj6 & _A_obj6, const T_obj7 & _A_obj7)</td></tr>
+<tr class="memdesc:ga5ea3e9f52643d7ab1bcfa4f419e7d38f"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="classsigc_1_1track__obj__functor7.html" title="track_obj_functor7 wraps a functor and stores 7 references to trackable objects.">sigc::track_obj_functor7</a> which wraps a functor. <a href="group__track__obj.html#ga5ea3e9f52643d7ab1bcfa4f419e7d38f">More...</a><br /></td></tr>
+<tr class="separator:ga5ea3e9f52643d7ab1bcfa4f419e7d38f"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<p><a class="el" href="group__track__obj.html#ga8fd1ab36d123ff83dd4cd8dc58bb28e2" title="Creates an adaptor of type sigc::track_obj_functor1 which wraps a functor.">sigc::track_obj()</a> tracks trackable objects, referenced from a functor. </p>
+<p>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 <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> derived objects.</p>
+<p>The functor returned by <a class="el" href="group__track__obj.html#ga8fd1ab36d123ff83dd4cd8dc58bb28e2" title="Creates an adaptor of type sigc::track_obj_functor1 which wraps a functor.">sigc::track_obj()</a> is formally an adaptor, but it does not alter the signature, return type or behaviour of the supplied functor. Up to 7 objects can be tracked. operator()() can have up to 7 arguments.</p>
+<dl class="section user"><dt>Example:</dt><dd><div class="fragment"><div class="line"><span class="keyword">struct </span>bar : <span class="keyword">public</span> <a class="code" href="structsigc_1_1trackable.html">sigc::trackable</a> {};</div>
+<div class="line"><a class="code" href="classsigc_1_1signal.html">sigc::signal<void></a> some_signal;</div>
+<div class="line"><span class="keywordtype">void</span> foo(bar&);</div>
+<div class="line">{</div>
+<div class="line"> bar some_bar;</div>
+<div class="line"> some_signal.<a class="code" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">connect</a>([&some_bar](){ foo(some_bar); });</div>
+<div class="line"> <span class="comment">// NOT disconnected automatically when some_bar goes out of scope</span></div>
+<div class="line"> some_signal.<a class="code" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">connect</a>(<a class="code" href="group__track__obj.html#ga8fd1ab36d123ff83dd4cd8dc58bb28e2">sigc::track_obj</a>([&some_bar](){ foo(some_bar); }, some_bar);</div>
+<div class="line"> <span class="comment">// disconnected automatically when some_bar goes out of scope</span></div>
+<div class="line">}</div>
+<div class="ttc" id="aclasssigc_1_1signal7_html_adc55ac9b0f935fd87a67904022e03cb2"><div class="ttname"><a href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2">sigc::signal7::connect</a></div><div class="ttdeci">iterator connect(const slot_type &slot_)</div><div class="ttdoc">Add a slot to the list of slots.</div><div class="ttdef"><b>Definition:</b> signal.h:3871</div></div>
+<div class="ttc" id="aclasssigc_1_1signal_html"><div class="ttname"><a href="classsigc_1_1signal.html">sigc::signal</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::signal# templates.</div><div class="ttdef"><b>Definition:</b> signal.h:4015</div></div>
+<div class="ttc" id="agroup__track__obj_html_ga8fd1ab36d123ff83dd4cd8dc58bb28e2"><div class="ttname"><a href="group__track__obj.html#ga8fd1ab36d123ff83dd4cd8dc58bb28e2">sigc::track_obj</a></div><div class="ttdeci">track_obj_functor1< T_functor, T_obj1 > track_obj(const T_functor &_A_func, const T_obj1 &_A_obj1)</div><div class="ttdoc">Creates an adaptor of type sigc::track_obj_functor1 which wraps a functor.</div><div class="ttdef"><b>Definition:</b> track_obj.h:743</div></div>
+<div class="ttc" id="astructsigc_1_1trackable_html"><div class="ttname"><a href="structsigc_1_1trackable.html">sigc::trackable</a></div><div class="ttdoc">Base class for objects with auto-disconnection.</div><div class="ttdef"><b>Definition:</b> trackable.h:110</div></div>
+</div><!-- fragment --></dd></dl>
+<dl class="since_2_4"><dt><b><a class="el" href="since_2_4.html#_since_2_4000001">Since libsigc++ 2.4:</a></b></dt><dd></dd></dl>
+<h2 class="groupheader">Function Documentation</h2>
+<a id="ga8fd1ab36d123ff83dd4cd8dc58bb28e2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga8fd1ab36d123ff83dd4cd8dc58bb28e2">◆ </a></span>track_obj() <span class="overload">[1/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_functor , typename T_obj1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1track__obj__functor1.html">track_obj_functor1</a><T_functor, T_obj1> sigc::track_obj </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj1 & </td>
+ <td class="paramname"><em>_A_obj1</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object.">sigc::track_obj_functor1</a> which wraps a functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Functor that shall be wrapped. </td></tr>
+ <tr><td class="paramname">_A_obj1</td><td>Trackable object. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes _A_func() on invocation.</dd></dl>
+<dl class="since_2_4"><dt><b><a class="el" href="since_2_4.html#_since_2_4000009">Since libsigc++ 2.4:</a></b></dt><dd></dd></dl>
+
+</div>
+</div>
+<a id="ga60842510c2387ec49c43149d94fb1b72"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga60842510c2387ec49c43149d94fb1b72">◆ </a></span>track_obj() <span class="overload">[2/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_functor , typename T_obj1 , typename T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1track__obj__functor2.html">track_obj_functor2</a><T_functor, T_obj1, T_obj2> sigc::track_obj </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj1 & </td>
+ <td class="paramname"><em>_A_obj1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj2 & </td>
+ <td class="paramname"><em>_A_obj2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="classsigc_1_1track__obj__functor2.html" title="track_obj_functor2 wraps a functor and stores 2 references to trackable objects.">sigc::track_obj_functor2</a> which wraps a functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Functor that shall be wrapped. </td></tr>
+ <tr><td class="paramname">_A_obj1</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj2</td><td>Trackable object. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes _A_func() on invocation.</dd></dl>
+<dl class="since_2_4"><dt><b><a class="el" href="since_2_4.html#_since_2_4000010">Since libsigc++ 2.4:</a></b></dt><dd></dd></dl>
+
+</div>
+</div>
+<a id="ga52b11304cb05441237a8dcc651cb724e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga52b11304cb05441237a8dcc651cb724e">◆ </a></span>track_obj() <span class="overload">[3/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_functor , typename T_obj1 , typename T_obj2 , typename T_obj3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1track__obj__functor3.html">track_obj_functor3</a><T_functor, T_obj1, T_obj2, T_obj3> sigc::track_obj </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj1 & </td>
+ <td class="paramname"><em>_A_obj1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj2 & </td>
+ <td class="paramname"><em>_A_obj2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj3 & </td>
+ <td class="paramname"><em>_A_obj3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="classsigc_1_1track__obj__functor3.html" title="track_obj_functor3 wraps a functor and stores 3 references to trackable objects.">sigc::track_obj_functor3</a> which wraps a functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Functor that shall be wrapped. </td></tr>
+ <tr><td class="paramname">_A_obj1</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj2</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj3</td><td>Trackable object. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes _A_func() on invocation.</dd></dl>
+<dl class="since_2_4"><dt><b><a class="el" href="since_2_4.html#_since_2_4000011">Since libsigc++ 2.4:</a></b></dt><dd></dd></dl>
+
+</div>
+</div>
+<a id="gaea44f2388c18ca8508818ff6b7756216"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaea44f2388c18ca8508818ff6b7756216">◆ </a></span>track_obj() <span class="overload">[4/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_functor , typename T_obj1 , typename T_obj2 , typename T_obj3 , typename T_obj4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1track__obj__functor4.html">track_obj_functor4</a><T_functor, T_obj1, T_obj2, T_obj3, T_obj4> sigc::track_obj </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj1 & </td>
+ <td class="paramname"><em>_A_obj1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj2 & </td>
+ <td class="paramname"><em>_A_obj2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj3 & </td>
+ <td class="paramname"><em>_A_obj3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj4 & </td>
+ <td class="paramname"><em>_A_obj4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="classsigc_1_1track__obj__functor4.html" title="track_obj_functor4 wraps a functor and stores 4 references to trackable objects.">sigc::track_obj_functor4</a> which wraps a functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Functor that shall be wrapped. </td></tr>
+ <tr><td class="paramname">_A_obj1</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj2</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj3</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj4</td><td>Trackable object. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes _A_func() on invocation.</dd></dl>
+<dl class="since_2_4"><dt><b><a class="el" href="since_2_4.html#_since_2_4000012">Since libsigc++ 2.4:</a></b></dt><dd></dd></dl>
+
+</div>
+</div>
+<a id="ga337dc48ba1e394f572d5d914b83f57a0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga337dc48ba1e394f572d5d914b83f57a0">◆ </a></span>track_obj() <span class="overload">[5/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_functor , typename T_obj1 , typename T_obj2 , typename T_obj3 , typename T_obj4 , typename T_obj5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1track__obj__functor5.html">track_obj_functor5</a><T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5> sigc::track_obj </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj1 & </td>
+ <td class="paramname"><em>_A_obj1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj2 & </td>
+ <td class="paramname"><em>_A_obj2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj3 & </td>
+ <td class="paramname"><em>_A_obj3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj4 & </td>
+ <td class="paramname"><em>_A_obj4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj5 & </td>
+ <td class="paramname"><em>_A_obj5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="classsigc_1_1track__obj__functor5.html" title="track_obj_functor5 wraps a functor and stores 5 references to trackable objects.">sigc::track_obj_functor5</a> which wraps a functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Functor that shall be wrapped. </td></tr>
+ <tr><td class="paramname">_A_obj1</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj2</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj3</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj4</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj5</td><td>Trackable object. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes _A_func() on invocation.</dd></dl>
+<dl class="since_2_4"><dt><b><a class="el" href="since_2_4.html#_since_2_4000013">Since libsigc++ 2.4:</a></b></dt><dd></dd></dl>
+
+</div>
+</div>
+<a id="ga0304ca1269ed352fcc1c81324062302e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga0304ca1269ed352fcc1c81324062302e">◆ </a></span>track_obj() <span class="overload">[6/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_functor , typename T_obj1 , typename T_obj2 , typename T_obj3 , typename T_obj4 , typename T_obj5 , typename T_obj6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1track__obj__functor6.html">track_obj_functor6</a><T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6> sigc::track_obj </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj1 & </td>
+ <td class="paramname"><em>_A_obj1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj2 & </td>
+ <td class="paramname"><em>_A_obj2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj3 & </td>
+ <td class="paramname"><em>_A_obj3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj4 & </td>
+ <td class="paramname"><em>_A_obj4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj5 & </td>
+ <td class="paramname"><em>_A_obj5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj6 & </td>
+ <td class="paramname"><em>_A_obj6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="classsigc_1_1track__obj__functor6.html" title="track_obj_functor6 wraps a functor and stores 6 references to trackable objects.">sigc::track_obj_functor6</a> which wraps a functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Functor that shall be wrapped. </td></tr>
+ <tr><td class="paramname">_A_obj1</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj2</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj3</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj4</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj5</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj6</td><td>Trackable object. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes _A_func() on invocation.</dd></dl>
+<dl class="since_2_4"><dt><b><a class="el" href="since_2_4.html#_since_2_4000014">Since libsigc++ 2.4:</a></b></dt><dd></dd></dl>
+
+</div>
+</div>
+<a id="ga5ea3e9f52643d7ab1bcfa4f419e7d38f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga5ea3e9f52643d7ab1bcfa4f419e7d38f">◆ </a></span>track_obj() <span class="overload">[7/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_functor , typename T_obj1 , typename T_obj2 , typename T_obj3 , typename T_obj4 , typename T_obj5 , typename T_obj6 , typename T_obj7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1track__obj__functor7.html">track_obj_functor7</a><T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6, T_obj7> sigc::track_obj </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj1 & </td>
+ <td class="paramname"><em>_A_obj1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj2 & </td>
+ <td class="paramname"><em>_A_obj2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj3 & </td>
+ <td class="paramname"><em>_A_obj3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj4 & </td>
+ <td class="paramname"><em>_A_obj4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj5 & </td>
+ <td class="paramname"><em>_A_obj5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj6 & </td>
+ <td class="paramname"><em>_A_obj6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_obj7 & </td>
+ <td class="paramname"><em>_A_obj7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates an adaptor of type <a class="el" href="classsigc_1_1track__obj__functor7.html" title="track_obj_functor7 wraps a functor and stores 7 references to trackable objects.">sigc::track_obj_functor7</a> which wraps a functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Functor that shall be wrapped. </td></tr>
+ <tr><td class="paramname">_A_obj1</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj2</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj3</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj4</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj5</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj6</td><td>Trackable object. </td></tr>
+ <tr><td class="paramname">_A_obj7</td><td>Trackable object. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Adaptor that executes _A_func() on invocation.</dd></dl>
+<dl class="since_2_4"><dt><b><a class="el" href="since_2_4.html#_since_2_4000015">Since libsigc++ 2.4:</a></b></dt><dd></dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Hierarchy</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">Class Hierarchy</div> </div>
+</div><!--header-->
+<div class="contents">
+<div class="textblock">
+<p><a href="inherits.html">Go to the graphical class hierarchy</a></p>
+This inheritance list is sorted roughly, but not completely, alphabetically:</div><div class="directory">
+<div class="levels">[detail level <span onclick="javascript:toggleLevel(1);">1</span><span onclick="javascript:toggleLevel(2);">2</span><span onclick="javascript:toggleLevel(3);">3</span><span onclick="javascript:toggleLevel(4);">4</span><span onclick="javascript:toggleLevel(5);">5</span>]</div><table class="directory">
+<tr id="row_0_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__argument.html" target="_self">sigc::bound_argument< T_bound ></a></td><td class="desc"></td></tr>
+<tr id="row_1_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__argument.html" target="_self">sigc::bound_argument< T_return ></a></td><td class="desc"></td></tr>
+<tr id="row_2_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__argument.html" target="_self">sigc::bound_argument< T_type1 ></a></td><td class="desc"></td></tr>
+<tr id="row_3_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__limit__reference.html" target="_self">sigc::const_limit_reference< T_obj ></a></td><td class="desc"></td></tr>
+<tr id="row_4_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__limit__reference.html" target="_self">sigc::const_limit_reference< T_wrapped ></a></td><td class="desc"></td></tr>
+<tr id="row_5_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__limit__reference.html" target="_self">sigc::const_volatile_limit_reference< T_obj ></a></td><td class="desc"></td></tr>
+<tr id="row_6_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1limit__reference.html" target="_self">sigc::limit_reference< T_obj ></a></td><td class="desc"></td></tr>
+<tr id="row_7_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1limit__reference.html" target="_self">sigc::limit_reference< T_wrapped ></a></td><td class="desc"></td></tr>
+<tr id="row_8_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1adaptor__trait.html" target="_self">sigc::adaptor_trait< T_functor, I_isadaptor ></a></td><td class="desc">Trait that specifies what is the adaptor version of a functor type </td></tr>
+<tr id="row_9_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html" target="_self">sigc::adaptor_trait< T_functor, false ></a></td><td class="desc">Trait that specifies what is the adaptor version of a functor type </td></tr>
+<tr id="row_10_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html" target="_self">sigc::adaptor_trait< T_functor, true ></a></td><td class="desc">Trait that specifies what is the adaptor version of a functor type </td></tr>
+<tr id="row_11_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1bind__functor.html" target="_self">sigc::bind_functor< I_location, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 ></a></td><td class="desc">Adaptor that binds an argument to the wrapped functor </td></tr>
+<tr id="row_12_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__argument.html" target="_self">sigc::bound_argument< T_type ></a></td><td class="desc">A bound_argument<Foo> object stores a bound (for instance, with <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">sigc::bind()</a>, or <a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a" title="Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed funct...">sigc::bind_return()</a>) argument </td></tr>
+<tr id="row_13_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html" target="_self">sigc::bound_argument< const_reference_wrapper< T_wrapped > ></a></td><td class="desc">Bound_argument object for a bound argument that is passed by <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">bind()</a> or returned by <a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a" title="Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed funct...">bind_return()</a> by const reference, specialized for const reference_wrapper<> types </td></tr>
+<tr id="row_14_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html" target="_self">sigc::bound_argument< reference_wrapper< T_wrapped > ></a></td><td class="desc">Bound_argument object for a bound argument that is passed by <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">bind()</a> or returned by <a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a" title="Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed funct...">bind_return()</a> by reference, specialized for reference_wrapper<> types </td></tr>
+<tr id="row_15_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html" target="_self">sigc::bound_argument< std::reference_wrapper< T_wrapped > ></a></td><td class="desc">Bound_argument object for a bound argument that is passed by <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">bind()</a> or returned by <a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a" title="Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed funct...">bind_return()</a> by reference, specialized for std::reference_wrapper<> types </td></tr>
+<tr id="row_16_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1can__deduce__result__type__with__decltype.html" target="_self">sigc::can_deduce_result_type_with_decltype< T_functor ></a></td><td class="desc">Helper class, to determine if decltype() can deduce the result type of a functor </td></tr>
+<tr id="row_17_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1connection.html" target="_self">sigc::connection</a></td><td class="desc">Convinience class for safe disconnection </td></tr>
+<tr id="row_18_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__limit__reference.html" target="_self">sigc::const_limit_reference< T_type, I_derives_trackable ></a></td><td class="desc">A const_limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>, then <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each<>()</a> will "limit" itself to the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference instead of the derived reference </td></tr>
+<tr id="row_19_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html" target="_self">sigc::const_limit_reference< T_type, true ></a></td><td class="desc">Const_limit_reference object for a class that derives from trackable </td></tr>
+<tr id="row_20_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1const__reference__wrapper.html" target="_self">sigc::const_reference_wrapper< T_type ></a></td><td class="desc">Const reference wrapper </td></tr>
+<tr id="row_21_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__limit__reference.html" target="_self">sigc::const_volatile_limit_reference< T_type, I_derives_trackable ></a></td><td class="desc">A const_volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>, then <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each<>()</a> will "limit" itself to the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference instead of the derived reference </td></tr>
+<tr id="row_22_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html" target="_self">sigc::const_volatile_limit_reference< T_type, true ></a></td><td class="desc">Const_volatile_limit_reference object for a class that derives from trackable </td></tr>
+<tr id="row_23_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1deduce__result__type.html" target="_self">sigc::deduce_result_type< T_functor, T_args ></a></td><td class="desc">Deduce the return type of a functor </td></tr>
+<tr id="row_24_" class="even"><td class="entry"><span style="width:0px;display:inline-block;"> </span><span id="arr_24_" class="arrow" onclick="toggleFolder('24_')">▼</span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1functor__base.html" target="_self">sigc::functor_base</a></td><td class="desc">A hint to the compiler </td></tr>
+<tr id="row_24_0_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_0_" class="arrow" onclick="toggleFolder('24_0_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1adaptor__base.html" target="_self">sigc::adaptor_base</a></td><td class="desc">A hint to the compiler </td></tr>
+<tr id="row_24_0_0_" class="even" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span id="arr_24_0_0_" class="arrow" onclick="toggleFolder('24_0_0_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1adapts.html" target="_self">sigc::adapts< T_setter ></a></td><td class="desc"></td></tr>
+<tr id="row_24_0_0_0_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1compose1__functor.html" target="_self">sigc::compose1_functor< T_setter, T_getter ></a></td><td class="desc">Adaptor that combines two functors </td></tr>
+<tr id="row_24_0_0_1_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1compose2__functor.html" target="_self">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a></td><td class="desc">Adaptor that combines three functors </td></tr>
+<tr id="row_24_0_1_" class="even" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1adaptor__functor.html" target="_self">sigc::adaptor_functor< T_functor ></a></td><td class="desc">Converts an arbitrary functor into an adaptor type </td></tr>
+<tr id="row_24_0_2_" class="even" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span id="arr_24_0_2_" class="arrow" onclick="toggleFolder('24_0_2_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1adapts.html" target="_self">sigc::adapts< T_functor ></a></td><td class="desc">Base type for adaptors </td></tr>
+<tr id="row_24_0_2_0_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a></td><td class="desc">Adaptor that binds an argument to the wrapped functor </td></tr>
+<tr id="row_24_0_2_1_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a></td><td class="desc">Adaptor that binds 1 argument(s) to the wrapped functor </td></tr>
+<tr id="row_24_0_2_2_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1bind__return__functor.html" target="_self">sigc::bind_return_functor< T_return, T_functor ></a></td><td class="desc">Adaptor that fixes the return value of the wrapped functor </td></tr>
+<tr id="row_24_0_2_3_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1exception__catch__functor.html" target="_self">sigc::exception_catch_functor< T_functor, T_catcher, T_return ></a></td><td class="desc"></td></tr>
+<tr id="row_24_0_2_4_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html" target="_self">sigc::exception_catch_functor< T_functor, T_catcher, void ></a></td><td class="desc"></td></tr>
+<tr id="row_24_0_2_5_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html" target="_self">sigc::hide_functor< 0, T_functor ></a></td><td class="desc">Adaptor that adds a dummy parameter to the wrapped functor </td></tr>
+<tr id="row_24_0_2_6_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html" target="_self">sigc::hide_functor<-1, T_functor ></a></td><td class="desc">Adaptor that adds a dummy parameter to the wrapped functor </td></tr>
+<tr id="row_24_0_2_7_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1retype__functor.html" target="_self">sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 ></a></td><td class="desc">Adaptor that performs C-style casts on the parameters passed on to the functor </td></tr>
+<tr id="row_24_0_2_8_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1retype__return__functor.html" target="_self">sigc::retype_return_functor< T_return, T_functor ></a></td><td class="desc">Adaptor that performs a C-style cast on the return value of a functor </td></tr>
+<tr id="row_24_0_2_9_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html" target="_self">sigc::retype_return_functor< void, T_functor ></a></td><td class="desc">Adaptor that performs a C-style cast on the return value of a functor </td></tr>
+<tr id="row_24_0_2_10_" class="even" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span id="arr_24_0_2_10_" class="arrow" onclick="toggleFolder('24_0_2_10_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1track__obj__functor1.html" target="_self">sigc::track_obj_functor1< T_functor, T_obj1 ></a></td><td class="desc">Track_obj_functor1 wraps a functor and stores a reference to a trackable object </td></tr>
+<tr id="row_24_0_2_10_0_" class="even" style="display:none;"><td class="entry"><span style="width:80px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1track__obj__functor2.html" target="_self">sigc::track_obj_functor2< T_functor, T_obj1, T_obj2 ></a></td><td class="desc">Track_obj_functor2 wraps a functor and stores 2 references to trackable objects </td></tr>
+<tr id="row_24_0_2_10_1_" class="even" style="display:none;"><td class="entry"><span style="width:80px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1track__obj__functor3.html" target="_self">sigc::track_obj_functor3< T_functor, T_obj1, T_obj2, T_obj3 ></a></td><td class="desc">Track_obj_functor3 wraps a functor and stores 3 references to trackable objects </td></tr>
+<tr id="row_24_0_2_10_2_" class="even" style="display:none;"><td class="entry"><span style="width:80px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1track__obj__functor4.html" target="_self">sigc::track_obj_functor4< T_functor, T_obj1, T_obj2, T_obj3, T_obj4 ></a></td><td class="desc">Track_obj_functor4 wraps a functor and stores 4 references to trackable objects </td></tr>
+<tr id="row_24_0_2_10_3_" class="even" style="display:none;"><td class="entry"><span style="width:80px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1track__obj__functor5.html" target="_self">sigc::track_obj_functor5< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5 ></a></td><td class="desc">Track_obj_functor5 wraps a functor and stores 5 references to trackable objects </td></tr>
+<tr id="row_24_0_2_10_4_" class="even" style="display:none;"><td class="entry"><span style="width:80px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1track__obj__functor6.html" target="_self">sigc::track_obj_functor6< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6 ></a></td><td class="desc">Track_obj_functor6 wraps a functor and stores 6 references to trackable objects </td></tr>
+<tr id="row_24_0_2_10_5_" class="even" style="display:none;"><td class="entry"><span style="width:80px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1track__obj__functor7.html" target="_self">sigc::track_obj_functor7< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6, T_obj7 ></a></td><td class="desc">Track_obj_functor7 wraps a functor and stores 7 references to trackable objects </td></tr>
+<tr id="row_24_1_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_1_" class="arrow" onclick="toggleFolder('24_1_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__mem__functor0.html" target="_self">sigc::const_mem_functor0< T_return, T_obj ></a></td><td class="desc">Const_mem_functor0 wraps const methods with 0 argument(s) </td></tr>
+<tr id="row_24_1_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__mem__functor0.html" target="_self">sigc::bound_const_mem_functor0< T_return, T_obj ></a></td><td class="desc">Bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance </td></tr>
+<tr id="row_24_2_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_2_" class="arrow" onclick="toggleFolder('24_2_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__mem__functor1.html" target="_self">sigc::const_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="desc">Const_mem_functor1 wraps const methods with 1 argument(s) </td></tr>
+<tr id="row_24_2_0_" class="even" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__mem__functor1.html" target="_self">sigc::bound_const_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="desc">Bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance </td></tr>
+<tr id="row_24_3_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_3_" class="arrow" onclick="toggleFolder('24_3_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__mem__functor2.html" target="_self">sigc::const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="desc">Const_mem_functor2 wraps const methods with 2 argument(s) </td></tr>
+<tr id="row_24_3_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__mem__functor2.html" target="_self">sigc::bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="desc">Bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance </td></tr>
+<tr id="row_24_4_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_4_" class="arrow" onclick="toggleFolder('24_4_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__mem__functor3.html" target="_self">sigc::const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="desc">Const_mem_functor3 wraps const methods with 3 argument(s) </td></tr>
+<tr id="row_24_4_0_" class="even" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__mem__functor3.html" target="_self">sigc::bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="desc">Bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance </td></tr>
+<tr id="row_24_5_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_5_" class="arrow" onclick="toggleFolder('24_5_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__mem__functor4.html" target="_self">sigc::const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="desc">Const_mem_functor4 wraps const methods with 4 argument(s) </td></tr>
+<tr id="row_24_5_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__mem__functor4.html" target="_self">sigc::bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="desc">Bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance </td></tr>
+<tr id="row_24_6_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_6_" class="arrow" onclick="toggleFolder('24_6_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__mem__functor5.html" target="_self">sigc::const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="desc">Const_mem_functor5 wraps const methods with 5 argument(s) </td></tr>
+<tr id="row_24_6_0_" class="even" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__mem__functor5.html" target="_self">sigc::bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="desc">Bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance </td></tr>
+<tr id="row_24_7_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_7_" class="arrow" onclick="toggleFolder('24_7_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__mem__functor6.html" target="_self">sigc::const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="desc">Const_mem_functor6 wraps const methods with 6 argument(s) </td></tr>
+<tr id="row_24_7_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__mem__functor6.html" target="_self">sigc::bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="desc">Bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance </td></tr>
+<tr id="row_24_8_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_8_" class="arrow" onclick="toggleFolder('24_8_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__mem__functor7.html" target="_self">sigc::const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="desc">Const_mem_functor7 wraps const methods with 7 argument(s) </td></tr>
+<tr id="row_24_8_0_" class="even" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__mem__functor7.html" target="_self">sigc::bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="desc">Bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance </td></tr>
+<tr id="row_24_9_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_9_" class="arrow" onclick="toggleFolder('24_9_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html" target="_self">sigc::const_volatile_mem_functor0< T_return, T_obj ></a></td><td class="desc">Const_volatile_mem_functor0 wraps const volatile methods with 0 argument(s) </td></tr>
+<tr id="row_24_9_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html" target="_self">sigc::bound_const_volatile_mem_functor0< T_return, T_obj ></a></td><td class="desc">Bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object instance </td></tr>
+<tr id="row_24_10_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_10_" class="arrow" onclick="toggleFolder('24_10_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html" target="_self">sigc::const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="desc">Const_volatile_mem_functor1 wraps const volatile methods with 1 argument(s) </td></tr>
+<tr id="row_24_10_0_" class="even" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html" target="_self">sigc::bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="desc">Bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object instance </td></tr>
+<tr id="row_24_11_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_11_" class="arrow" onclick="toggleFolder('24_11_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html" target="_self">sigc::const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="desc">Const_volatile_mem_functor2 wraps const volatile methods with 2 argument(s) </td></tr>
+<tr id="row_24_11_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html" target="_self">sigc::bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="desc">Bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object instance </td></tr>
+<tr id="row_24_12_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_12_" class="arrow" onclick="toggleFolder('24_12_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html" target="_self">sigc::const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="desc">Const_volatile_mem_functor3 wraps const volatile methods with 3 argument(s) </td></tr>
+<tr id="row_24_12_0_" class="even" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html" target="_self">sigc::bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="desc">Bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object instance </td></tr>
+<tr id="row_24_13_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_13_" class="arrow" onclick="toggleFolder('24_13_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html" target="_self">sigc::const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="desc">Const_volatile_mem_functor4 wraps const volatile methods with 4 argument(s) </td></tr>
+<tr id="row_24_13_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html" target="_self">sigc::bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="desc">Bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object instance </td></tr>
+<tr id="row_24_14_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_14_" class="arrow" onclick="toggleFolder('24_14_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html" target="_self">sigc::const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="desc">Const_volatile_mem_functor5 wraps const volatile methods with 5 argument(s) </td></tr>
+<tr id="row_24_14_0_" class="even" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html" target="_self">sigc::bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="desc">Bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object instance </td></tr>
+<tr id="row_24_15_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_15_" class="arrow" onclick="toggleFolder('24_15_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html" target="_self">sigc::const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="desc">Const_volatile_mem_functor6 wraps const volatile methods with 6 argument(s) </td></tr>
+<tr id="row_24_15_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html" target="_self">sigc::bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="desc">Bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object instance </td></tr>
+<tr id="row_24_16_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_16_" class="arrow" onclick="toggleFolder('24_16_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html" target="_self">sigc::const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="desc">Const_volatile_mem_functor7 wraps const volatile methods with 7 argument(s) </td></tr>
+<tr id="row_24_16_0_" class="even" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html" target="_self">sigc::bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="desc">Bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object instance </td></tr>
+<tr id="row_24_17_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_17_" class="arrow" onclick="toggleFolder('24_17_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1mem__functor0.html" target="_self">sigc::mem_functor0< T_return, T_obj ></a></td><td class="desc">Mem_functor0 wraps methods with 0 argument(s) </td></tr>
+<tr id="row_24_17_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__mem__functor0.html" target="_self">sigc::bound_mem_functor0< T_return, T_obj ></a></td><td class="desc">Bound_mem_functor0 encapsulates a method with 0 arguments and an object instance </td></tr>
+<tr id="row_24_18_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_18_" class="arrow" onclick="toggleFolder('24_18_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1mem__functor1.html" target="_self">sigc::mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="desc">Mem_functor1 wraps methods with 1 argument(s) </td></tr>
+<tr id="row_24_18_0_" class="even" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__mem__functor1.html" target="_self">sigc::bound_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="desc">Bound_mem_functor1 encapsulates a method with 1 arguments and an object instance </td></tr>
+<tr id="row_24_19_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_19_" class="arrow" onclick="toggleFolder('24_19_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1mem__functor2.html" target="_self">sigc::mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="desc">Mem_functor2 wraps methods with 2 argument(s) </td></tr>
+<tr id="row_24_19_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__mem__functor2.html" target="_self">sigc::bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="desc">Bound_mem_functor2 encapsulates a method with 2 arguments and an object instance </td></tr>
+<tr id="row_24_20_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_20_" class="arrow" onclick="toggleFolder('24_20_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1mem__functor3.html" target="_self">sigc::mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="desc">Mem_functor3 wraps methods with 3 argument(s) </td></tr>
+<tr id="row_24_20_0_" class="even" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__mem__functor3.html" target="_self">sigc::bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="desc">Bound_mem_functor3 encapsulates a method with 3 arguments and an object instance </td></tr>
+<tr id="row_24_21_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_21_" class="arrow" onclick="toggleFolder('24_21_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1mem__functor4.html" target="_self">sigc::mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="desc">Mem_functor4 wraps methods with 4 argument(s) </td></tr>
+<tr id="row_24_21_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__mem__functor4.html" target="_self">sigc::bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="desc">Bound_mem_functor4 encapsulates a method with 4 arguments and an object instance </td></tr>
+<tr id="row_24_22_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_22_" class="arrow" onclick="toggleFolder('24_22_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1mem__functor5.html" target="_self">sigc::mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="desc">Mem_functor5 wraps methods with 5 argument(s) </td></tr>
+<tr id="row_24_22_0_" class="even" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__mem__functor5.html" target="_self">sigc::bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="desc">Bound_mem_functor5 encapsulates a method with 5 arguments and an object instance </td></tr>
+<tr id="row_24_23_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_23_" class="arrow" onclick="toggleFolder('24_23_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1mem__functor6.html" target="_self">sigc::mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="desc">Mem_functor6 wraps methods with 6 argument(s) </td></tr>
+<tr id="row_24_23_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__mem__functor6.html" target="_self">sigc::bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="desc">Bound_mem_functor6 encapsulates a method with 6 arguments and an object instance </td></tr>
+<tr id="row_24_24_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_24_" class="arrow" onclick="toggleFolder('24_24_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1mem__functor7.html" target="_self">sigc::mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="desc">Mem_functor7 wraps methods with 7 argument(s) </td></tr>
+<tr id="row_24_24_0_" class="even" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__mem__functor7.html" target="_self">sigc::bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="desc">Bound_mem_functor7 encapsulates a method with 7 arguments and an object instance </td></tr>
+<tr id="row_24_25_" class="even"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1pointer__functor0.html" target="_self">sigc::pointer_functor0< T_return ></a></td><td class="desc">Pointer_functor0 wraps existing non-member functions with 0 argument(s) </td></tr>
+<tr id="row_24_26_"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1pointer__functor1.html" target="_self">sigc::pointer_functor1< T_arg1, T_return ></a></td><td class="desc">Pointer_functor1 wraps existing non-member functions with 1 argument(s) </td></tr>
+<tr id="row_24_27_" class="even"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1pointer__functor2.html" target="_self">sigc::pointer_functor2< T_arg1, T_arg2, T_return ></a></td><td class="desc">Pointer_functor2 wraps existing non-member functions with 2 argument(s) </td></tr>
+<tr id="row_24_28_"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1pointer__functor3.html" target="_self">sigc::pointer_functor3< T_arg1, T_arg2, T_arg3, T_return ></a></td><td class="desc">Pointer_functor3 wraps existing non-member functions with 3 argument(s) </td></tr>
+<tr id="row_24_29_" class="even"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1pointer__functor4.html" target="_self">sigc::pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return ></a></td><td class="desc">Pointer_functor4 wraps existing non-member functions with 4 argument(s) </td></tr>
+<tr id="row_24_30_"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1pointer__functor5.html" target="_self">sigc::pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return ></a></td><td class="desc">Pointer_functor5 wraps existing non-member functions with 5 argument(s) </td></tr>
+<tr id="row_24_31_" class="even"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1pointer__functor6.html" target="_self">sigc::pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return ></a></td><td class="desc">Pointer_functor6 wraps existing non-member functions with 6 argument(s) </td></tr>
+<tr id="row_24_32_"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1pointer__functor7.html" target="_self">sigc::pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return ></a></td><td class="desc">Pointer_functor7 wraps existing non-member functions with 7 argument(s) </td></tr>
+<tr id="row_24_33_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_33_" class="arrow" onclick="toggleFolder('24_33_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot__base.html" target="_self">sigc::slot_base</a></td><td class="desc">Base type for slots </td></tr>
+<tr id="row_24_33_0_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span id="arr_24_33_0_" class="arrow" onclick="toggleFolder('24_33_0_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot7.html" target="_self">sigc::slot7< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="desc"></td></tr>
+<tr id="row_24_33_0_0_" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot.html" target="_self">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a># templates </td></tr>
+<tr id="row_24_33_1_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span id="arr_24_33_1_" class="arrow" onclick="toggleFolder('24_33_1_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot0.html" target="_self">sigc::slot0< T_return ></a></td><td class="desc">Converts an arbitrary functor to a unified type which is opaque </td></tr>
+<tr id="row_24_33_1_0_" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot0.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot0</a> template </td></tr>
+<tr id="row_24_33_2_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span id="arr_24_33_2_" class="arrow" onclick="toggleFolder('24_33_2_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot1.html" target="_self">sigc::slot1< T_return, T_arg1 ></a></td><td class="desc">Converts an arbitrary functor to a unified type which is opaque </td></tr>
+<tr id="row_24_33_2_0_" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot1.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot1</a> template </td></tr>
+<tr id="row_24_33_3_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span id="arr_24_33_3_" class="arrow" onclick="toggleFolder('24_33_3_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot2.html" target="_self">sigc::slot2< T_return, T_arg1, T_arg2 ></a></td><td class="desc">Converts an arbitrary functor to a unified type which is opaque </td></tr>
+<tr id="row_24_33_3_0_" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot2.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot2</a> template </td></tr>
+<tr id="row_24_33_4_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span id="arr_24_33_4_" class="arrow" onclick="toggleFolder('24_33_4_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot3.html" target="_self">sigc::slot3< T_return, T_arg1, T_arg2, T_arg3 ></a></td><td class="desc">Converts an arbitrary functor to a unified type which is opaque </td></tr>
+<tr id="row_24_33_4_0_" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot3.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot3</a> template </td></tr>
+<tr id="row_24_33_5_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span id="arr_24_33_5_" class="arrow" onclick="toggleFolder('24_33_5_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot4.html" target="_self">sigc::slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="desc">Converts an arbitrary functor to a unified type which is opaque </td></tr>
+<tr id="row_24_33_5_0_" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot4.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot4</a> template </td></tr>
+<tr id="row_24_33_6_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span id="arr_24_33_6_" class="arrow" onclick="toggleFolder('24_33_6_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot5.html" target="_self">sigc::slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="desc">Converts an arbitrary functor to a unified type which is opaque </td></tr>
+<tr id="row_24_33_6_0_" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html" target="_self">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot5.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot5</a> template </td></tr>
+<tr id="row_24_33_7_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span id="arr_24_33_7_" class="arrow" onclick="toggleFolder('24_33_7_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot6.html" target="_self">sigc::slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="desc">Converts an arbitrary functor to a unified type which is opaque </td></tr>
+<tr id="row_24_33_7_0_" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html" target="_self">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot6.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot6</a> template </td></tr>
+<tr id="row_24_33_8_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot7.html" target="_self">sigc::slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="desc">Converts an arbitrary functor to a unified type which is opaque </td></tr>
+<tr id="row_24_33_9_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html" target="_self">sigc::slot< T_return(T_arg...)></a></td><td class="desc">Converts an arbitrary functor to a unified type which is opaque </td></tr>
+<tr id="row_24_34_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_34_" class="arrow" onclick="toggleFolder('24_34_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__mem__functor0.html" target="_self">sigc::volatile_mem_functor0< T_return, T_obj ></a></td><td class="desc">Volatile_mem_functor0 wraps volatile methods with 0 argument(s) </td></tr>
+<tr id="row_24_34_0_" class="even" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html" target="_self">sigc::bound_volatile_mem_functor0< T_return, T_obj ></a></td><td class="desc">Bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance </td></tr>
+<tr id="row_24_35_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_35_" class="arrow" onclick="toggleFolder('24_35_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__mem__functor1.html" target="_self">sigc::volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="desc">Volatile_mem_functor1 wraps volatile methods with 1 argument(s) </td></tr>
+<tr id="row_24_35_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html" target="_self">sigc::bound_volatile_mem_functor1< T_return, T_obj, T_arg1 ></a></td><td class="desc">Bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance </td></tr>
+<tr id="row_24_36_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_36_" class="arrow" onclick="toggleFolder('24_36_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__mem__functor2.html" target="_self">sigc::volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="desc">Volatile_mem_functor2 wraps volatile methods with 2 argument(s) </td></tr>
+<tr id="row_24_36_0_" class="even" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html" target="_self">sigc::bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></a></td><td class="desc">Bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance </td></tr>
+<tr id="row_24_37_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_37_" class="arrow" onclick="toggleFolder('24_37_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__mem__functor3.html" target="_self">sigc::volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="desc">Volatile_mem_functor3 wraps volatile methods with 3 argument(s) </td></tr>
+<tr id="row_24_37_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html" target="_self">sigc::bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></a></td><td class="desc">Bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance </td></tr>
+<tr id="row_24_38_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_38_" class="arrow" onclick="toggleFolder('24_38_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__mem__functor4.html" target="_self">sigc::volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="desc">Volatile_mem_functor4 wraps volatile methods with 4 argument(s) </td></tr>
+<tr id="row_24_38_0_" class="even" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html" target="_self">sigc::bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></a></td><td class="desc">Bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance </td></tr>
+<tr id="row_24_39_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_39_" class="arrow" onclick="toggleFolder('24_39_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__mem__functor5.html" target="_self">sigc::volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="desc">Volatile_mem_functor5 wraps volatile methods with 5 argument(s) </td></tr>
+<tr id="row_24_39_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html" target="_self">sigc::bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></a></td><td class="desc">Bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance </td></tr>
+<tr id="row_24_40_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_40_" class="arrow" onclick="toggleFolder('24_40_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__mem__functor6.html" target="_self">sigc::volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="desc">Volatile_mem_functor6 wraps volatile methods with 6 argument(s) </td></tr>
+<tr id="row_24_40_0_" class="even" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html" target="_self">sigc::bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></a></td><td class="desc">Bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance </td></tr>
+<tr id="row_24_41_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_24_41_" class="arrow" onclick="toggleFolder('24_41_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__mem__functor7.html" target="_self">sigc::volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="desc">Volatile_mem_functor7 wraps volatile methods with 7 argument(s) </td></tr>
+<tr id="row_24_41_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html" target="_self">sigc::bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="desc">Bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance </td></tr>
+<tr id="row_25_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1functor__trait.html" target="_self">sigc::functor_trait< T_functor, I_derives_functor_base, I_can_use_decltype ></a></td><td class="desc">Trait that specifies the return type of any type </td></tr>
+<tr id="row_26_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1hide__functor.html" target="_self">sigc::hide_functor< I_location, T_functor ></a></td><td class="desc">Adaptor that adds a dummy parameter to the wrapped functor </td></tr>
+<tr id="row_27_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1limit__reference.html" target="_self">sigc::limit_reference< T_type, I_derives_trackable ></a></td><td class="desc">A limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>, then <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each<>()</a> will "limit" itself to the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference instead of the derived reference </td></tr>
+<tr id="row_28_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html" target="_self">sigc::limit_reference< T_type, true ></a></td><td class="desc">Limit_reference object for a class that derives from trackable </td></tr>
+<tr id="row_29_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1nil.html" target="_self">sigc::nil</a></td><td class="desc">Nil struct type </td></tr>
+<tr id="row_30_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1reference__wrapper.html" target="_self">sigc::reference_wrapper< T_type ></a></td><td class="desc">Reference wrapper </td></tr>
+<tr id="row_31_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1slot__const__iterator.html" target="_self">sigc::slot_const_iterator< T_slot ></a></td><td class="desc">STL-style const iterator for <a class="el" href="structsigc_1_1slot__list.html" title="STL-style list interface for sigc::signal#.">slot_list</a> </td></tr>
+<tr id="row_32_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1slot__iterator.html" target="_self">sigc::slot_iterator< T_slot ></a></td><td class="desc">STL-style iterator for <a class="el" href="structsigc_1_1slot__list.html" title="STL-style list interface for sigc::signal#.">slot_list</a> </td></tr>
+<tr id="row_33_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1slot__list.html" target="_self">sigc::slot_list< T_slot ></a></td><td class="desc">STL-style list interface for <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># </td></tr>
+<tr id="row_34_" class="even"><td class="entry"><span style="width:0px;display:inline-block;"> </span><span id="arr_34_" class="arrow" onclick="toggleFolder('34_')">▼</span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1trackable.html" target="_self">sigc::trackable</a></td><td class="desc">Base class for objects with auto-disconnection </td></tr>
+<tr id="row_34_0_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_34_0_" class="arrow" onclick="toggleFolder('34_0_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1signal__base.html" target="_self">sigc::signal_base</a></td><td class="desc">Base class for the <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates </td></tr>
+<tr id="row_34_0_0_" class="even" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span id="arr_34_0_0_" class="arrow" onclick="toggleFolder('34_0_0_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal0.html" target="_self">sigc::signal0< T_return, T_accumulator ></a></td><td class="desc"></td></tr>
+<tr id="row_34_0_0_0_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html" target="_self">sigc::signal< T_return()>::accumulated< T_accumulator ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal0.html" title="Signal declaration.">sigc::signal0</a> template </td></tr>
+<tr id="row_34_0_0_1_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html" target="_self">sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil >::accumulated< T_accumulator ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal0.html" title="Signal declaration.">sigc::signal0</a> template </td></tr>
+<tr id="row_34_0_1_" class="even" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span id="arr_34_0_1_" class="arrow" onclick="toggleFolder('34_0_1_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal0.html" target="_self">sigc::signal0< T_return, nil ></a></td><td class="desc"></td></tr>
+<tr id="row_34_0_1_0_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4.html" target="_self">sigc::signal< T_return()></a></td><td class="desc">This specialization allow use of the sigc::signal<R(Args...)> syntax, </td></tr>
+<tr id="row_34_0_1_1_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal0.html" title="Signal declaration.">sigc::signal0</a> template </td></tr>
+<tr id="row_34_0_2_" class="even" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span id="arr_34_0_2_" class="arrow" onclick="toggleFolder('34_0_2_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal1.html" target="_self">sigc::signal1< T_return, T_arg1, nil ></a></td><td class="desc"></td></tr>
+<tr id="row_34_0_2_0_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html" target="_self">sigc::signal< T_return(T_arg1)></a></td><td class="desc">This specialization allow use of the sigc::signal<R(Args...)> syntax, </td></tr>
+<tr id="row_34_0_2_1_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal1.html" title="Signal declaration.">sigc::signal1</a> template </td></tr>
+<tr id="row_34_0_3_" class="even" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span id="arr_34_0_3_" class="arrow" onclick="toggleFolder('34_0_3_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal1.html" target="_self">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="desc"></td></tr>
+<tr id="row_34_0_3_0_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html" target="_self">sigc::signal< T_return(T_arg1)>::accumulated< T_accumulator ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal1.html" title="Signal declaration.">sigc::signal1</a> template </td></tr>
+<tr id="row_34_0_3_1_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html" target="_self">sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::accumulated< T_accumulator ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal1.html" title="Signal declaration.">sigc::signal1</a> template </td></tr>
+<tr id="row_34_0_4_" class="even" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span id="arr_34_0_4_" class="arrow" onclick="toggleFolder('34_0_4_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal2.html" target="_self">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="desc"></td></tr>
+<tr id="row_34_0_4_0_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html" target="_self">sigc::signal< T_return(T_arg1, T_arg2)>::accumulated< T_accumulator ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal2.html" title="Signal declaration.">sigc::signal2</a> template </td></tr>
+<tr id="row_34_0_4_1_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html" target="_self">sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::accumulated< T_accumulator ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal2.html" title="Signal declaration.">sigc::signal2</a> template </td></tr>
+<tr id="row_34_0_5_" class="even" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span id="arr_34_0_5_" class="arrow" onclick="toggleFolder('34_0_5_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal2.html" target="_self">sigc::signal2< T_return, T_arg1, T_arg2, nil ></a></td><td class="desc"></td></tr>
+<tr id="row_34_0_5_0_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html" target="_self">sigc::signal< T_return(T_arg1, T_arg2)></a></td><td class="desc">This specialization allow use of the sigc::signal<R(Args...)> syntax, </td></tr>
+<tr id="row_34_0_5_1_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal2.html" title="Signal declaration.">sigc::signal2</a> template </td></tr>
+<tr id="row_34_0_6_" class="even" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span id="arr_34_0_6_" class="arrow" onclick="toggleFolder('34_0_6_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal3.html" target="_self">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="desc"></td></tr>
+<tr id="row_34_0_6_0_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html" target="_self">sigc::signal< T_return(T_arg1, T_arg2, T_arg3)>::accumulated< T_accumulator ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal3.html" title="Signal declaration.">sigc::signal3</a> template </td></tr>
+<tr id="row_34_0_6_1_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html" target="_self">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::accumulated< T_accumulator ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal3.html" title="Signal declaration.">sigc::signal3</a> template </td></tr>
+<tr id="row_34_0_7_" class="even" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span id="arr_34_0_7_" class="arrow" onclick="toggleFolder('34_0_7_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal3.html" target="_self">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></a></td><td class="desc"></td></tr>
+<tr id="row_34_0_7_0_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html" target="_self">sigc::signal< T_return(T_arg1, T_arg2, T_arg3)></a></td><td class="desc">This specialization allow use of the sigc::signal<R(Args...)> syntax, </td></tr>
+<tr id="row_34_0_7_1_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal3.html" title="Signal declaration.">sigc::signal3</a> template </td></tr>
+<tr id="row_34_0_8_" class="even" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span id="arr_34_0_8_" class="arrow" onclick="toggleFolder('34_0_8_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal4.html" target="_self">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></a></td><td class="desc"></td></tr>
+<tr id="row_34_0_8_0_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html" target="_self">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)></a></td><td class="desc">This specialization allow use of the sigc::signal<R(Args...)> syntax, </td></tr>
+<tr id="row_34_0_8_1_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal4.html" title="Signal declaration.">sigc::signal4</a> template </td></tr>
+<tr id="row_34_0_9_" class="even" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span id="arr_34_0_9_" class="arrow" onclick="toggleFolder('34_0_9_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal4.html" target="_self">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="desc"></td></tr>
+<tr id="row_34_0_9_0_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html" target="_self">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::accumulated< T_accumulator ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal4.html" title="Signal declaration.">sigc::signal4</a> template </td></tr>
+<tr id="row_34_0_9_1_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html" target="_self">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::accumulated< T_accumulator ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal4.html" title="Signal declaration.">sigc::signal4</a> template </td></tr>
+<tr id="row_34_0_10_" class="even" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span id="arr_34_0_10_" class="arrow" onclick="toggleFolder('34_0_10_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal5.html" target="_self">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="desc"></td></tr>
+<tr id="row_34_0_10_0_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html" target="_self">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::accumulated< T_accumulator ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal5.html" title="Signal declaration.">sigc::signal5</a> template </td></tr>
+<tr id="row_34_0_10_1_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html" target="_self">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::accumulated< T_accumulator ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal5.html" title="Signal declaration.">sigc::signal5</a> template </td></tr>
+<tr id="row_34_0_11_" class="even" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span id="arr_34_0_11_" class="arrow" onclick="toggleFolder('34_0_11_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal5.html" target="_self">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></a></td><td class="desc"></td></tr>
+<tr id="row_34_0_11_0_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html" target="_self">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)></a></td><td class="desc">This specialization allow use of the sigc::signal<R(Args...)> syntax, </td></tr>
+<tr id="row_34_0_11_1_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html" target="_self">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal5.html" title="Signal declaration.">sigc::signal5</a> template </td></tr>
+<tr id="row_34_0_12_" class="even" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span id="arr_34_0_12_" class="arrow" onclick="toggleFolder('34_0_12_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal6.html" target="_self">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="desc"></td></tr>
+<tr id="row_34_0_12_0_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html" target="_self">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::accumulated< T_accumulator ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal6.html" title="Signal declaration.">sigc::signal6</a> template </td></tr>
+<tr id="row_34_0_12_1_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html" target="_self">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::accumulated< T_accumulator ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal6.html" title="Signal declaration.">sigc::signal6</a> template </td></tr>
+<tr id="row_34_0_13_" class="even" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span id="arr_34_0_13_" class="arrow" onclick="toggleFolder('34_0_13_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal6.html" target="_self">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="desc"></td></tr>
+<tr id="row_34_0_13_0_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html" target="_self">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)></a></td><td class="desc">This specialization allow use of the sigc::signal<R(Args...)> syntax, </td></tr>
+<tr id="row_34_0_13_1_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html" target="_self">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal6.html" title="Signal declaration.">sigc::signal6</a> template </td></tr>
+<tr id="row_34_0_14_" class="even" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span id="arr_34_0_14_" class="arrow" onclick="toggleFolder('34_0_14_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal7.html" target="_self">sigc::signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="desc"></td></tr>
+<tr id="row_34_0_14_0_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal.html" target="_self">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates </td></tr>
+<tr id="row_34_0_15_" class="even" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span id="arr_34_0_15_" class="arrow" onclick="toggleFolder('34_0_15_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal7.html" target="_self">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="desc"></td></tr>
+<tr id="row_34_0_15_0_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_1_1accumulated.html" target="_self">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::accumulated< T_accumulator ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates </td></tr>
+<tr id="row_34_0_15_1_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html" target="_self">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::accumulated< T_accumulator ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates </td></tr>
+<tr id="row_34_0_16_" class="even" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span id="arr_34_0_16_" class="arrow" onclick="toggleFolder('34_0_16_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal7.html" target="_self">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil ></a></td><td class="desc"></td></tr>
+<tr id="row_34_0_16_0_" class="even" style="display:none;"><td class="entry"><span style="width:64px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html" target="_self">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)></a></td><td class="desc">This specialization allow use of the sigc::signal<R(Args...)> syntax, </td></tr>
+<tr id="row_34_0_17_" class="even" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal0.html" target="_self">sigc::signal0< T_return, T_accumulator ></a></td><td class="desc">Signal declaration </td></tr>
+<tr id="row_34_0_18_" class="even" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal1.html" target="_self">sigc::signal1< T_return, T_arg1, T_accumulator ></a></td><td class="desc">Signal declaration </td></tr>
+<tr id="row_34_0_19_" class="even" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal2.html" target="_self">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator ></a></td><td class="desc">Signal declaration </td></tr>
+<tr id="row_34_0_20_" class="even" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal3.html" target="_self">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></a></td><td class="desc">Signal declaration </td></tr>
+<tr id="row_34_0_21_" class="even" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal4.html" target="_self">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></a></td><td class="desc">Signal declaration </td></tr>
+<tr id="row_34_0_22_" class="even" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal5.html" target="_self">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></a></td><td class="desc">Signal declaration </td></tr>
+<tr id="row_34_0_23_" class="even" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal6.html" target="_self">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></a></td><td class="desc">Signal declaration </td></tr>
+<tr id="row_34_0_24_" class="even" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal7.html" target="_self">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></a></td><td class="desc">Signal declaration </td></tr>
+<tr id="row_35_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1type__trait.html" target="_self">sigc::type_trait< T_type ></a></td><td class="desc"></td></tr>
+<tr id="row_36_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html" target="_self">sigc::type_trait< const T_type & ></a></td><td class="desc"></td></tr>
+<tr id="row_37_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1type__trait_3_01T__type_01_6_01_4.html" target="_self">sigc::type_trait< T_type & ></a></td><td class="desc"></td></tr>
+<tr id="row_38_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html" target="_self">sigc::type_trait< T_type[N]></a></td><td class="desc"></td></tr>
+<tr id="row_39_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1type__trait_3_01void_01_4.html" target="_self">sigc::type_trait< void ></a></td><td class="desc"></td></tr>
+<tr id="row_40_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1unwrap__reference.html" target="_self">sigc::unwrap_reference< T_type ></a></td><td class="desc"></td></tr>
+<tr id="row_41_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1unwrap__reference_3_01const__reference__wrapper_3_01T__type_01_4_01_4.html" target="_self">sigc::unwrap_reference< const_reference_wrapper< T_type > ></a></td><td class="desc"></td></tr>
+<tr id="row_42_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1unwrap__reference_3_01reference__wrapper_3_01T__type_01_4_01_4.html" target="_self">sigc::unwrap_reference< reference_wrapper< T_type > ></a></td><td class="desc"></td></tr>
+<tr id="row_43_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1unwrap__reference_3_01std_1_1reference__wrapper_3_01T__type_01_4_01_4.html" target="_self">sigc::unwrap_reference< std::reference_wrapper< T_type > ></a></td><td class="desc"></td></tr>
+<tr id="row_44_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1visitor.html" target="_self">sigc::visitor< T_functor ></a></td><td class="desc">Sigc::visitor<T_functor>::do_visit_each() performs a functor on each of the targets of a functor </td></tr>
+<tr id="row_45_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__limit__reference.html" target="_self">sigc::volatile_limit_reference< T_type, I_derives_trackable ></a></td><td class="desc">A volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>, then <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each<>()</a> will "limit" itself to the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference instead of the derived reference </td></tr>
+<tr id="row_46_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html" target="_self">sigc::volatile_limit_reference< T_type, true ></a></td><td class="desc">Volatile_limit_reference object for a class that derives from trackable </td></tr>
+<tr id="row_47_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__limit__reference.html" target="_self">sigc::volatile_limit_reference< T_obj ></a></td><td class="desc"></td></tr>
+</table>
+</div><!-- directory -->
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: libsigc++ Reference Manual</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="PageDoc"><div class="header">
+ <div class="headertitle">
+<div class="title">libsigc++ Reference Manual </div> </div>
+</div><!--header-->
+<div class="contents">
+<div class="textblock"><h1><a class="anchor" id="description"></a>
+Description</h1>
+<p>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.</p>
+<p>For instance, see the <a class="el" href="group__signal.html">Signals</a>, <a class="el" href="group__sigcfunctors.html">Functors</a>, <a class="el" href="group__slot.html">Slots</a> and <a class="el" href="group__adaptors.html">Adaptors</a>.</p>
+<p>See also the <a href="https://developer.gnome.org/libsigc++-tutorial/2.10/">libsigc++ tutorial</a>, the <a href="https://libsigcplusplus.github.io/libsigcplusplus/">libsigc++ website</a>, and the <a href="https://developer.gnome.org/gtkmm-tutorial/3.24/chapter-signals.html">Signals appendix of the Programming with gtkmm book</a>.</p>
+<h1><a class="anchor" id="features"></a>
+Features</h1>
+<ul>
+<li>Compile-time typesafe callbacks (also faster than run time checks)</li>
+<li>Type-safety violations report the line number correctly with template names (no tracing template failures into headers)</li>
+<li>No compiler extensions or meta compilers required</li>
+<li>Proper handling of dynamic objects and signals (deleted objects will not cause crashes)</li>
+<li>Extendable API at any level: signal, slot, connection and trackable</li>
+<li>Extensions do not require alteration of basic components</li>
+<li>User-definable accumulators</li>
+<li>A variety of adaptors to change the callback signature: bind, hide, retype, and compose</li>
+</ul>
+<h1><a class="anchor" id="basics"></a>
+Basic Usage</h1>
+<p>Include the libsigc++ header: </p><div class="fragment"><div class="line"><span class="preprocessor">#include <sigc++/sigc++.h></span></div>
+</div><!-- fragment --><p> (You may include individual headers, such as <code>sigc++/bind</code>.h instead.)</p>
+<p>If your source file is <code>program.cc</code>, you can compile it with: </p><div class="fragment"><div class="line">g++ program.cc -o program `pkg-config --cflags --libs <a class="code" href="namespacesigc.html">sigc</a>++-2.0`</div>
+<div class="ttc" id="anamespacesigc_html"><div class="ttname"><a href="namespacesigc.html">sigc</a></div><div class="ttdoc">The libsigc++ namespace.</div><div class="ttdef"><b>Definition:</b> limit_reference.h:12</div></div>
+</div><!-- fragment --><p> If your version of g++ is not C++11-compliant by default, add the <code>-std=c++11</code> option.</p>
+<h2><a class="anchor" id="meson"></a>
+Using Meson</h2>
+<p>If using <a href="https://mesonbuild.com/">Meson</a>, include the following in <code>meson.build:</code> </p><div class="fragment"><div class="line">sigc_dep = dependency(<span class="stringliteral">'sigc++-2.0'</span>)</div>
+<div class="line">program_name = 'program'</div>
+<div class="line">cpp_sources = [ 'program.cc' ]</div>
+<div class="line">executable(program_name,</div>
+<div class="line"> cpp_sources,</div>
+<div class="line"> dependencies: sigc_dep</div>
+<div class="line">)</div>
+</div><!-- fragment --><p>Your <code>dependencies:</code> keyword argument should also mention any other libraries that you need to use.</p>
+<h2><a class="anchor" id="autotools"></a>
+Using Autotools</h2>
+<p>Alternatively, if using autoconf, use the following in <code>configure.ac:</code> </p><div class="fragment"><div class="line">PKG_CHECK_MODULES([DEPS], [<a class="code" href="namespacesigc.html">sigc</a>++-2.0])</div>
+</div><!-- fragment --><p> Then use the generated <code>DEPS_CFLAGS</code> and <code>DEPS_LIBS</code> variables in the project <code>Makefile.am</code> files. For example: </p><div class="fragment"><div class="line">yourprogram_CPPFLAGS = $(DEPS_CFLAGS)</div>
+<div class="line">yourprogram_LDADD = $(DEPS_LIBS)</div>
+</div><!-- fragment --><p>Your <code>PKG_CHECK_MODULES()</code> call should also mention any other libraries that you need to use via pkg-config.</p>
+<h2><a class="anchor" id="cmake"></a>
+Using CMake</h2>
+<p>If using CMake, use the following in <code>CMakeList.txt:</code> </p><div class="fragment"><div class="line">include(FindPkgConfig)</div>
+<div class="line">pkg_check_modules(DEPS REQUIRED <a class="code" href="namespacesigc.html">sigc</a>++-2.0)</div>
+<div class="line">include_directories(${DEPS_INCLUDE_DIRS})</div>
+<div class="line">target_link_libraries(yourprogram ${DEPS_LIBRARIES})</div>
+</div><!-- fragment --><p>Your <code>pkg_check_modules()</code> call should also mention any other libraries that you need to use via pkg-config.</p>
+<h1><a class="anchor" id="scope"></a>
+Scope of Documentation</h1>
+<p>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. </p>
+</div></div><!-- PageDoc -->
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html" title="Trait that specifies what is the adaptor version of a functor type." alt="" coords="5,5,159,47"/>
+</map>
--- /dev/null
+23064b5bf4ddca6e0270c62656664e52
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$structsigc_1_1adaptor__trait.html" title="Trait that specifies what is the adaptor version of a functor type." alt="" coords="5,5,199,47"/>
+</map>
--- /dev/null
+da5486ffef12746ecf1ba8edfb40eebd
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$classsigc_1_1bound__argument.html" title=" " alt="" coords="5,5,172,47"/>
+</map>
--- /dev/null
+a52e4842c469068e1ffa13c344930807
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$classsigc_1_1can__deduce__result__type__with__decltype.html" title="Helper class, to determine if decltype() can deduce the result type of a functor." alt="" coords="5,5,184,61"/>
+</map>
--- /dev/null
+1ba4d7b5bdd0cbac718e32cd460183a9
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$structsigc_1_1connection.html" title="Convinience class for safe disconnection." alt="" coords="5,5,132,32"/>
+</map>
--- /dev/null
+26ed045cdbc13fab42706e262a62dfd4
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$classsigc_1_1const__limit__reference.html" title=" " alt="" coords="5,5,203,47"/>
+</map>
--- /dev/null
+3ecbfd46fd862b90666b978c70c4281e
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$classsigc_1_1const__limit__reference.html" title="A const_limit_reference<Foo> object stores a reference (Foo&), but make sure that,..." alt="" coords="5,5,236,47"/>
+</map>
--- /dev/null
+5cd69f3eb107508ab62a3fa0143a94d3
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html" title="const_limit_reference object for a class that derives from trackable." alt="" coords="5,5,203,47"/>
+</map>
--- /dev/null
+fab533fbdf1801428482b3ab0eb721a6
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$classsigc_1_1const__limit__reference.html" title=" " alt="" coords="5,5,203,47"/>
+</map>
--- /dev/null
+0a93f7fd5f799e9af3209512000661c5
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$structsigc_1_1const__reference__wrapper.html" title="Const reference wrapper." alt="" coords="5,5,165,47"/>
+</map>
--- /dev/null
+e51de9d26694ddda872bbebe690558da
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$classsigc_1_1const__volatile__limit__reference.html" title=" " alt="" coords="5,5,199,47"/>
+</map>
--- /dev/null
+650f5aeb3844cae3cd6b7fe57fe33051
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$classsigc_1_1const__volatile__limit__reference.html" title="A const_volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that,..." alt="" coords="5,5,196,61"/>
+</map>
--- /dev/null
+586ead680d9911c2c2e9189a81ebae3f
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html" title="Trait that specifies what is the adaptor version of a functor type." alt="" coords="5,5,152,47"/>
+</map>
--- /dev/null
+17fbc463fe4f91b02dae7d319afe53ef
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html" title="const_volatile_limit_reference object for a class that derives from trackable." alt="" coords="5,5,196,61"/>
+</map>
--- /dev/null
+179b1af57bfbd0fda896a4364a361050
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$structsigc_1_1deduce__result__type.html" title="Deduce the return type of a functor." alt="" coords="5,5,156,61"/>
+</map>
--- /dev/null
+ea140d519e38211631b60e91b3e5ff7e
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,2311,145,2338"/>
+<area shape="rect" id="node2" href="$structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="227,479,371,506"/>
+<area shape="rect" id="node25" href="$classsigc_1_1const__mem__functor0.html" title="const_mem_functor0 wraps const methods with 0 argument(s)." alt="" coords="202,577,395,619"/>
+<area shape="rect" id="node27" href="$classsigc_1_1const__mem__functor1.html" title="const_mem_functor1 wraps const methods with 1 argument(s)." alt="" coords="198,653,399,695"/>
+<area shape="rect" id="node29" href="$classsigc_1_1const__mem__functor2.html" title="const_mem_functor2 wraps const methods with 2 argument(s)." alt="" coords="202,727,395,783"/>
+<area shape="rect" id="node31" href="$classsigc_1_1const__mem__functor3.html" title="const_mem_functor3 wraps const methods with 3 argument(s)." alt="" coords="202,815,395,871"/>
+<area shape="rect" id="node33" href="$classsigc_1_1const__mem__functor4.html" title="const_mem_functor4 wraps const methods with 4 argument(s)." alt="" coords="202,905,395,961"/>
+<area shape="rect" id="node35" href="$classsigc_1_1const__mem__functor5.html" title="const_mem_functor5 wraps const methods with 5 argument(s)." alt="" coords="202,993,395,1064"/>
+<area shape="rect" id="node37" href="$classsigc_1_1const__mem__functor6.html" title="const_mem_functor6 wraps const methods with 6 argument(s)." alt="" coords="202,1092,395,1163"/>
+<area shape="rect" id="node39" href="$classsigc_1_1const__mem__functor7.html" title="const_mem_functor7 wraps const methods with 7 argument(s)." alt="" coords="202,1187,395,1257"/>
+<area shape="rect" id="node41" href="$classsigc_1_1const__volatile__mem__functor0.html" title="const_volatile_mem_functor0 wraps const volatile methods with 0 argument(s)." alt="" coords="200,1282,397,1338"/>
+<area shape="rect" id="node43" href="$classsigc_1_1const__volatile__mem__functor1.html" title="const_volatile_mem_functor1 wraps const volatile methods with 1 argument(s)." alt="" coords="200,1362,397,1418"/>
+<area shape="rect" id="node45" href="$classsigc_1_1const__volatile__mem__functor2.html" title="const_volatile_mem_functor2 wraps const volatile methods with 2 argument(s)." alt="" coords="200,1442,397,1498"/>
+<area shape="rect" id="node47" href="$classsigc_1_1const__volatile__mem__functor3.html" title="const_volatile_mem_functor3 wraps const volatile methods with 3 argument(s)." alt="" coords="200,1523,397,1593"/>
+<area shape="rect" id="node49" href="$classsigc_1_1const__volatile__mem__functor4.html" title="const_volatile_mem_functor4 wraps const volatile methods with 4 argument(s)." alt="" coords="200,1617,397,1688"/>
+<area shape="rect" id="node51" href="$classsigc_1_1const__volatile__mem__functor5.html" title="const_volatile_mem_functor5 wraps const volatile methods with 5 argument(s)." alt="" coords="200,1712,397,1783"/>
+<area shape="rect" id="node53" href="$classsigc_1_1const__volatile__mem__functor6.html" title="const_volatile_mem_functor6 wraps const volatile methods with 6 argument(s)." alt="" coords="200,1807,397,1893"/>
+<area shape="rect" id="node55" href="$classsigc_1_1const__volatile__mem__functor7.html" title="const_volatile_mem_functor7 wraps const volatile methods with 7 argument(s)." alt="" coords="200,1917,397,2002"/>
+<area shape="rect" id="node57" href="$classsigc_1_1mem__functor0.html" title="mem_functor0 wraps methods with 0 argument(s)." alt="" coords="223,2027,374,2068"/>
+<area shape="rect" id="node59" href="$classsigc_1_1mem__functor1.html" title="mem_functor1 wraps methods with 1 argument(s)." alt="" coords="223,2093,374,2149"/>
+<area shape="rect" id="node61" href="$classsigc_1_1mem__functor2.html" title="mem_functor2 wraps methods with 2 argument(s)." alt="" coords="223,2173,374,2229"/>
+<area shape="rect" id="node63" href="$classsigc_1_1mem__functor3.html" title="mem_functor3 wraps methods with 3 argument(s)." alt="" coords="210,2253,387,2309"/>
+<area shape="rect" id="node65" href="$classsigc_1_1mem__functor4.html" title="mem_functor4 wraps methods with 4 argument(s)." alt="" coords="215,2333,382,2404"/>
+<area shape="rect" id="node67" href="$classsigc_1_1mem__functor5.html" title="mem_functor5 wraps methods with 5 argument(s)." alt="" coords="215,2428,382,2499"/>
+<area shape="rect" id="node69" href="$classsigc_1_1mem__functor6.html" title="mem_functor6 wraps methods with 6 argument(s)." alt="" coords="204,2523,393,2593"/>
+<area shape="rect" id="node71" href="$classsigc_1_1mem__functor7.html" title="mem_functor7 wraps methods with 7 argument(s)." alt="" coords="209,2618,388,2703"/>
+<area shape="rect" id="node73" href="$classsigc_1_1pointer__functor0.html" title="pointer_functor0 wraps existing non-member functions with 0 argument(s)." alt="" coords="217,2728,380,2769"/>
+<area shape="rect" id="node74" href="$classsigc_1_1pointer__functor1.html" title="pointer_functor1 wraps existing non-member functions with 1 argument(s)." alt="" coords="217,2793,380,2835"/>
+<area shape="rect" id="node75" href="$classsigc_1_1pointer__functor2.html" title="pointer_functor2 wraps existing non-member functions with 2 argument(s)." alt="" coords="193,2859,404,2900"/>
+<area shape="rect" id="node76" href="$classsigc_1_1pointer__functor3.html" title="pointer_functor3 wraps existing non-member functions with 3 argument(s)." alt="" coords="204,2925,393,2981"/>
+<area shape="rect" id="node77" href="$classsigc_1_1pointer__functor4.html" title="pointer_functor4 wraps existing non-member functions with 4 argument(s)." alt="" coords="204,3005,393,3061"/>
+<area shape="rect" id="node78" href="$classsigc_1_1pointer__functor5.html" title="pointer_functor5 wraps existing non-member functions with 5 argument(s)." alt="" coords="199,3085,398,3141"/>
+<area shape="rect" id="node79" href="$classsigc_1_1pointer__functor6.html" title="pointer_functor6 wraps existing non-member functions with 6 argument(s)." alt="" coords="204,3165,393,3236"/>
+<area shape="rect" id="node80" href="$classsigc_1_1pointer__functor7.html" title="pointer_functor7 wraps existing non-member functions with 7 argument(s)." alt="" coords="204,3260,393,3331"/>
+<area shape="rect" id="node81" href="$classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="239,3355,358,3382"/>
+<area shape="rect" id="node100" href="$classsigc_1_1volatile__mem__functor0.html" title="volatile_mem_functor0 wraps volatile methods with 0 argument(s)." alt="" coords="221,3409,377,3465"/>
+<area shape="rect" id="node102" href="$classsigc_1_1volatile__mem__functor1.html" title="volatile_mem_functor1 wraps volatile methods with 1 argument(s)." alt="" coords="221,3494,377,3550"/>
+<area shape="rect" id="node104" href="$classsigc_1_1volatile__mem__functor2.html" title="volatile_mem_functor2 wraps volatile methods with 2 argument(s)." alt="" coords="209,3585,389,3641"/>
+<area shape="rect" id="node106" href="$classsigc_1_1volatile__mem__functor3.html" title="volatile_mem_functor3 wraps volatile methods with 3 argument(s)." alt="" coords="214,3687,383,3757"/>
+<area shape="rect" id="node108" href="$classsigc_1_1volatile__mem__functor4.html" title="volatile_mem_functor4 wraps volatile methods with 4 argument(s)." alt="" coords="214,3804,383,3875"/>
+<area shape="rect" id="node110" href="$classsigc_1_1volatile__mem__functor5.html" title="volatile_mem_functor5 wraps volatile methods with 5 argument(s)." alt="" coords="204,3899,393,3969"/>
+<area shape="rect" id="node112" href="$classsigc_1_1volatile__mem__functor6.html" title="volatile_mem_functor6 wraps volatile methods with 6 argument(s)." alt="" coords="209,3994,388,4079"/>
+<area shape="rect" id="node114" href="$classsigc_1_1volatile__mem__functor7.html" title="volatile_mem_functor7 wraps volatile methods with 7 argument(s)." alt="" coords="209,4103,388,4189"/>
+<area shape="rect" id="node3" href="$structsigc_1_1adapts.html" title=" " alt="" coords="477,86,659,113"/>
+<area shape="rect" id="node6" href="$structsigc_1_1adaptor__functor.html" title="Converts an arbitrary functor into an adaptor type." alt="" coords="489,443,647,484"/>
+<area shape="rect" id="node7" href="$structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="473,509,663,535"/>
+<area shape="rect" id="node4" href="$structsigc_1_1compose1__functor.html" title="Adaptor that combines two functors." alt="" coords="751,5,927,47"/>
+<area shape="rect" id="node5" href="$structsigc_1_1compose2__functor.html" title="Adaptor that combines three functors." alt="" coords="751,71,927,127"/>
+<area shape="rect" id="node8" href="$structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Adaptor that binds an argument to the wrapped functor." alt="" coords="748,151,929,207"/>
+<area shape="rect" id="node9" href="$structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Adaptor that binds 1 argument(s) to the wrapped functor." alt="" coords="749,231,928,287"/>
+<area shape="rect" id="node10" href="$structsigc_1_1bind__return__functor.html" title="Adaptor that fixes the return value of the wrapped functor." alt="" coords="747,312,930,353"/>
+<area shape="rect" id="node11" href="$structsigc_1_1exception__catch__functor.html" title=" " alt="" coords="755,378,922,434"/>
+<area shape="rect" id="node12" href="$structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html" title=" " alt="" coords="757,458,920,514"/>
+<area shape="rect" id="node13" href="$structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html" title="Adaptor that adds a dummy parameter to the wrapped functor." alt="" coords="770,539,907,580"/>
+<area shape="rect" id="node14" href="$structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html" title="Adaptor that adds a dummy parameter to the wrapped functor." alt="" coords="770,604,907,645"/>
+<area shape="rect" id="node15" href="$structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor." alt="" coords="732,669,945,740"/>
+<area shape="rect" id="node16" href="$structsigc_1_1retype__return__functor.html" title="Adaptor that performs a C-style cast on the return value of a functor." alt="" coords="765,765,913,821"/>
+<area shape="rect" id="node17" href="$structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html" title="Adaptor that performs a C-style cast on the return value of a functor." alt="" coords="737,845,940,887"/>
+<area shape="rect" id="node18" href="$classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object." alt="" coords="750,911,927,952"/>
+<area shape="rect" id="node19" href="$classsigc_1_1track__obj__functor2.html" title="track_obj_functor2 wraps a functor and stores 2 references to trackable objects." alt="" coords="999,717,1213,759"/>
+<area shape="rect" id="node20" href="$classsigc_1_1track__obj__functor3.html" title="track_obj_functor3 wraps a functor and stores 3 references to trackable objects." alt="" coords="1017,783,1195,839"/>
+<area shape="rect" id="node21" href="$classsigc_1_1track__obj__functor4.html" title="track_obj_functor4 wraps a functor and stores 4 references to trackable objects." alt="" coords="1017,863,1195,919"/>
+<area shape="rect" id="node22" href="$classsigc_1_1track__obj__functor5.html" title="track_obj_functor5 wraps a functor and stores 5 references to trackable objects." alt="" coords="993,943,1219,999"/>
+<area shape="rect" id="node23" href="$classsigc_1_1track__obj__functor6.html" title="track_obj_functor6 wraps a functor and stores 6 references to trackable objects." alt="" coords="1017,1024,1195,1095"/>
+<area shape="rect" id="node24" href="$classsigc_1_1track__obj__functor7.html" title="track_obj_functor7 wraps a functor and stores 7 references to trackable objects." alt="" coords="1017,1119,1195,1189"/>
+<area shape="rect" id="node26" href="$classsigc_1_1bound__const__mem__functor0.html" title="bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance." alt="" coords="479,559,657,615"/>
+<area shape="rect" id="node28" href="$classsigc_1_1bound__const__mem__functor1.html" title="bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance." alt="" coords="479,639,657,695"/>
+<area shape="rect" id="node30" href="$classsigc_1_1bound__const__mem__functor2.html" title="bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance." alt="" coords="478,719,658,775"/>
+<area shape="rect" id="node32" href="$classsigc_1_1bound__const__mem__functor3.html" title="bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance." alt="" coords="479,800,657,871"/>
+<area shape="rect" id="node34" href="$classsigc_1_1bound__const__mem__functor4.html" title="bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance." alt="" coords="479,895,657,965"/>
+<area shape="rect" id="node36" href="$classsigc_1_1bound__const__mem__functor5.html" title="bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance." alt="" coords="473,989,663,1060"/>
+<area shape="rect" id="node38" href="$classsigc_1_1bound__const__mem__functor6.html" title="bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance." alt="" coords="479,1085,657,1170"/>
+<area shape="rect" id="node40" href="$classsigc_1_1bound__const__mem__functor7.html" title="bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance." alt="" coords="479,1194,657,1279"/>
+<area shape="rect" id="node42" href="$classsigc_1_1bound__const__volatile__mem__functor0.html" title="bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object..." alt="" coords="469,1303,667,1359"/>
+<area shape="rect" id="node44" href="$classsigc_1_1bound__const__volatile__mem__functor1.html" title="bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object..." alt="" coords="469,1383,667,1439"/>
+<area shape="rect" id="node46" href="$classsigc_1_1bound__const__volatile__mem__functor2.html" title="bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object..." alt="" coords="469,1463,667,1519"/>
+<area shape="rect" id="node48" href="$classsigc_1_1bound__const__volatile__mem__functor3.html" title="bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object..." alt="" coords="452,1543,684,1599"/>
+<area shape="rect" id="node50" href="$classsigc_1_1bound__const__volatile__mem__functor4.html" title="bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object..." alt="" coords="469,1624,667,1695"/>
+<area shape="rect" id="node52" href="$classsigc_1_1bound__const__volatile__mem__functor5.html" title="bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object..." alt="" coords="469,1719,667,1789"/>
+<area shape="rect" id="node54" href="$classsigc_1_1bound__const__volatile__mem__functor6.html" title="bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object..." alt="" coords="453,1815,683,1885"/>
+<area shape="rect" id="node56" href="$classsigc_1_1bound__const__volatile__mem__functor7.html" title="bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object..." alt="" coords="459,1917,677,2002"/>
+<area shape="rect" id="node58" href="$classsigc_1_1bound__mem__functor0.html" title="bound_mem_functor0 encapsulates a method with 0 arguments and an object instance." alt="" coords="469,2027,667,2068"/>
+<area shape="rect" id="node60" href="$classsigc_1_1bound__mem__functor1.html" title="bound_mem_functor1 encapsulates a method with 1 arguments and an object instance." alt="" coords="467,2100,669,2141"/>
+<area shape="rect" id="node62" href="$classsigc_1_1bound__mem__functor2.html" title="bound_mem_functor2 encapsulates a method with 2 arguments and an object instance." alt="" coords="469,2173,667,2229"/>
+<area shape="rect" id="node64" href="$classsigc_1_1bound__mem__functor3.html" title="bound_mem_functor3 encapsulates a method with 3 arguments and an object instance." alt="" coords="469,2253,667,2309"/>
+<area shape="rect" id="node66" href="$classsigc_1_1bound__mem__functor4.html" title="bound_mem_functor4 encapsulates a method with 4 arguments and an object instance." alt="" coords="469,2341,667,2397"/>
+<area shape="rect" id="node68" href="$classsigc_1_1bound__mem__functor5.html" title="bound_mem_functor5 encapsulates a method with 5 arguments and an object instance." alt="" coords="469,2428,667,2499"/>
+<area shape="rect" id="node70" href="$classsigc_1_1bound__mem__functor6.html" title="bound_mem_functor6 encapsulates a method with 6 arguments and an object instance." alt="" coords="469,2523,667,2593"/>
+<area shape="rect" id="node72" href="$classsigc_1_1bound__mem__functor7.html" title="bound_mem_functor7 encapsulates a method with 7 arguments and an object instance." alt="" coords="469,2625,667,2696"/>
+<area shape="rect" id="node82" href="$classsigc_1_1slot7.html" title=" " alt="" coords="487,2723,649,2779"/>
+<area shape="rect" id="node84" href="$classsigc_1_1slot0.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="482,2810,654,2837"/>
+<area shape="rect" id="node86" href="$classsigc_1_1slot1.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="487,2875,649,2916"/>
+<area shape="rect" id="node88" href="$classsigc_1_1slot2.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="487,2951,649,2992"/>
+<area shape="rect" id="node90" href="$classsigc_1_1slot3.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="473,3023,663,3064"/>
+<area shape="rect" id="node92" href="$classsigc_1_1slot4.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="479,3089,657,3145"/>
+<area shape="rect" id="node94" href="$classsigc_1_1slot5.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="479,3169,657,3225"/>
+<area shape="rect" id="node96" href="$classsigc_1_1slot6.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="473,3249,663,3305"/>
+<area shape="rect" id="node98" href="$classsigc_1_1slot7.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="479,3329,657,3400"/>
+<area shape="rect" id="node99" href="$classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="493,3424,643,3465"/>
+<area shape="rect" id="node83" href="$classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates." alt="" coords="749,2684,928,2755"/>
+<area shape="rect" id="node85" href="$classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot0 template." alt="" coords="762,2779,915,2835"/>
+<area shape="rect" id="node87" href="$classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot1 template." alt="" coords="762,2859,915,2915"/>
+<area shape="rect" id="node89" href="$classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot2 template." alt="" coords="762,2939,915,2995"/>
+<area shape="rect" id="node91" href="$classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot3 template." alt="" coords="749,3019,928,3075"/>
+<area shape="rect" id="node93" href="$classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot4 template." alt="" coords="749,3099,928,3155"/>
+<area shape="rect" id="node95" href="$classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot5 template." alt="" coords="746,3179,931,3235"/>
+<area shape="rect" id="node97" href="$classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot6 template." alt="" coords="732,3259,945,3315"/>
+<area shape="rect" id="node101" href="$classsigc_1_1bound__volatile__mem__functor0.html" title="bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance." alt="" coords="469,3490,667,3546"/>
+<area shape="rect" id="node103" href="$classsigc_1_1bound__volatile__mem__functor1.html" title="bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance." alt="" coords="469,3570,667,3626"/>
+<area shape="rect" id="node105" href="$classsigc_1_1bound__volatile__mem__functor2.html" title="bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance." alt="" coords="469,3650,667,3706"/>
+<area shape="rect" id="node107" href="$classsigc_1_1bound__volatile__mem__functor3.html" title="bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance." alt="" coords="469,3731,667,3801"/>
+<area shape="rect" id="node109" href="$classsigc_1_1bound__volatile__mem__functor4.html" title="bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance." alt="" coords="469,3825,667,3896"/>
+<area shape="rect" id="node111" href="$classsigc_1_1bound__volatile__mem__functor5.html" title="bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance." alt="" coords="469,3920,667,3991"/>
+<area shape="rect" id="node113" href="$classsigc_1_1bound__volatile__mem__functor6.html" title="bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance." alt="" coords="469,4015,667,4101"/>
+<area shape="rect" id="node115" href="$classsigc_1_1bound__volatile__mem__functor7.html" title="bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance." alt="" coords="469,4125,667,4210"/>
+</map>
--- /dev/null
+fbd5a21142c512a89e41505ee31dfad0
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$structsigc_1_1functor__trait.html" title="Trait that specifies the return type of any type." alt="" coords="5,5,191,76"/>
+</map>
--- /dev/null
+557a9e3ab8da9dca554da03e3873bb42
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$structsigc_1_1hide__functor.html" title="Adaptor that adds a dummy parameter to the wrapped functor." alt="" coords="5,5,189,47"/>
+</map>
--- /dev/null
+24484ead6e8be2032c61754ad38f8f42
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$classsigc_1_1limit__reference.html" title=" " alt="" coords="5,5,160,47"/>
+</map>
--- /dev/null
+0351f22b0607f600c2c3dc9fd4fc73ea
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$classsigc_1_1limit__reference.html" title="A limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from sig..." alt="" coords="5,5,236,47"/>
+</map>
--- /dev/null
+7fb602afec830e51c594adff7547e907
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html" title="limit_reference object for a class that derives from trackable." alt="" coords="5,5,160,47"/>
+</map>
--- /dev/null
+6039fe4fbb0edc6a3a28919b0311338a
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$classsigc_1_1limit__reference.html" title=" " alt="" coords="5,5,160,47"/>
+</map>
--- /dev/null
+403767ed46c1901135c0b990d1592851
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$structsigc_1_1nil.html" title="nil struct type." alt="" coords="5,5,77,32"/>
+</map>
--- /dev/null
+09ba7acb24b89e9b075d929a820d022d
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor." alt="" coords="5,5,208,91"/>
+</map>
--- /dev/null
+39c55ee55ba3b734535eb57838274a26
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$structsigc_1_1reference__wrapper.html" title="Reference wrapper." alt="" coords="5,5,184,47"/>
+</map>
--- /dev/null
+c3e13ca9198ad2f840f34972e22d2c51
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$structsigc_1_1slot__const__iterator.html" title="STL-style const iterator for slot_list." alt="" coords="5,5,183,47"/>
+</map>
--- /dev/null
+f301bf8b1c4ce85df5b9b756866928bc
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$structsigc_1_1slot__iterator.html" title="STL-style iterator for slot_list." alt="" coords="5,5,140,47"/>
+</map>
--- /dev/null
+37f7e6fed46734859bbf6cb9fde3909f
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$structsigc_1_1slot__list.html" title="STL-style list interface for sigc::signal#." alt="" coords="5,5,136,47"/>
+</map>
--- /dev/null
+e562836d9699d3f3486c6bebeea4d5eb
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="5,1850,121,1877"/>
+<area shape="rect" id="node2" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="169,1850,303,1877"/>
+<area shape="rect" id="node3" href="$classsigc_1_1signal0.html" title=" " alt="" coords="383,85,559,127"/>
+<area shape="rect" id="node6" href="$classsigc_1_1signal0.html" title=" " alt="" coords="383,224,559,265"/>
+<area shape="rect" id="node9" href="$classsigc_1_1signal1.html" title=" " alt="" coords="383,371,559,412"/>
+<area shape="rect" id="node12" href="$classsigc_1_1signal1.html" title=" " alt="" coords="377,539,566,580"/>
+<area shape="rect" id="node15" href="$classsigc_1_1signal2.html" title=" " alt="" coords="351,715,592,756"/>
+<area shape="rect" id="node18" href="$classsigc_1_1signal2.html" title=" " alt="" coords="383,868,559,909"/>
+<area shape="rect" id="node21" href="$classsigc_1_1signal3.html" title=" " alt="" coords="382,1029,561,1085"/>
+<area shape="rect" id="node24" href="$classsigc_1_1signal3.html" title=" " alt="" coords="382,1182,561,1238"/>
+<area shape="rect" id="node27" href="$classsigc_1_1signal4.html" title=" " alt="" coords="382,1342,561,1398"/>
+<area shape="rect" id="node30" href="$classsigc_1_1signal4.html" title=" " alt="" coords="377,1525,566,1581"/>
+<area shape="rect" id="node33" href="$classsigc_1_1signal5.html" title=" " alt="" coords="351,1667,592,1723"/>
+<area shape="rect" id="node36" href="$classsigc_1_1signal5.html" title=" " alt="" coords="382,1747,561,1803"/>
+<area shape="rect" id="node39" href="$classsigc_1_1signal6.html" title=" " alt="" coords="382,1828,561,1899"/>
+<area shape="rect" id="node42" href="$classsigc_1_1signal6.html" title=" " alt="" coords="365,1923,578,1979"/>
+<area shape="rect" id="node45" href="$classsigc_1_1signal7.html" title=" " alt="" coords="383,2003,559,2059"/>
+<area shape="rect" id="node47" href="$classsigc_1_1signal7.html" title=" " alt="" coords="377,2084,566,2155"/>
+<area shape="rect" id="node50" href="$classsigc_1_1signal7.html" title=" " alt="" coords="382,2179,561,2249"/>
+<area shape="rect" id="node52" href="$classsigc_1_1signal0.html" title="Signal declaration." alt="" coords="383,2273,559,2315"/>
+<area shape="rect" id="node53" href="$classsigc_1_1signal1.html" title="Signal declaration." alt="" coords="377,2339,566,2380"/>
+<area shape="rect" id="node54" href="$classsigc_1_1signal2.html" title="Signal declaration." alt="" coords="351,2404,592,2445"/>
+<area shape="rect" id="node55" href="$classsigc_1_1signal3.html" title="Signal declaration." alt="" coords="382,2470,561,2526"/>
+<area shape="rect" id="node56" href="$classsigc_1_1signal4.html" title="Signal declaration." alt="" coords="377,2550,566,2606"/>
+<area shape="rect" id="node57" href="$classsigc_1_1signal5.html" title="Signal declaration." alt="" coords="351,2630,592,2686"/>
+<area shape="rect" id="node58" href="$classsigc_1_1signal6.html" title="Signal declaration." alt="" coords="382,2711,561,2781"/>
+<area shape="rect" id="node59" href="$classsigc_1_1signal7.html" title="Signal declaration." alt="" coords="377,2805,566,2876"/>
+<area shape="rect" id="node4" href="$classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal0 template." alt="" coords="647,5,908,47"/>
+<area shape="rect" id="node5" href="$classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal0 template." alt="" coords="691,71,864,141"/>
+<area shape="rect" id="node7" href="$classsigc_1_1signal_3_01T__return_07_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="685,166,870,193"/>
+<area shape="rect" id="node8" href="$classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal0 template." alt="" coords="693,217,861,273"/>
+<area shape="rect" id="node10" href="$classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="695,297,859,339"/>
+<area shape="rect" id="node11" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal1 template." alt="" coords="693,363,861,419"/>
+<area shape="rect" id="node13" href="$classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal1 template." alt="" coords="688,443,867,499"/>
+<area shape="rect" id="node14" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal1 template." alt="" coords="679,524,876,595"/>
+<area shape="rect" id="node16" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal2 template." alt="" coords="662,619,893,675"/>
+<area shape="rect" id="node17" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal2 template." alt="" coords="661,700,893,771"/>
+<area shape="rect" id="node19" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="695,795,859,836"/>
+<area shape="rect" id="node20" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal2 template." alt="" coords="693,861,861,917"/>
+<area shape="rect" id="node22" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal3 template." alt="" coords="652,941,903,997"/>
+<area shape="rect" id="node23" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html" title="Convenience wrapper for the numbered sigc::signal3 template." alt="" coords="667,1021,888,1092"/>
+<area shape="rect" id="node25" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="682,1116,873,1157"/>
+<area shape="rect" id="node26" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal3 template." alt="" coords="688,1182,867,1238"/>
+<area shape="rect" id="node28" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="688,1262,867,1318"/>
+<area shape="rect" id="node29" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal4 template." alt="" coords="688,1342,867,1398"/>
+<area shape="rect" id="node31" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal4 template." alt="" coords="683,1423,872,1493"/>
+<area shape="rect" id="node32" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html" title="Convenience wrapper for the numbered sigc::signal4 template." alt="" coords="657,1517,897,1588"/>
+<area shape="rect" id="node34" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal5 template." alt="" coords="662,1612,893,1683"/>
+<area shape="rect" id="node35" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html" title="Convenience wrapper for the numbered sigc::signal5 template." alt="" coords="650,1707,905,1777"/>
+<area shape="rect" id="node37" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="688,1802,867,1858"/>
+<area shape="rect" id="node38" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal5 template." alt="" coords="685,1882,870,1938"/>
+<area shape="rect" id="node40" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html" title="Convenience wrapper for the numbered sigc::signal6 template." alt="" coords="652,1963,903,2033"/>
+<area shape="rect" id="node41" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html" title="Convenience wrapper for the numbered sigc::signal6 template." alt="" coords="640,2057,915,2128"/>
+<area shape="rect" id="node43" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="682,2153,873,2209"/>
+<area shape="rect" id="node44" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal6 template." alt="" coords="671,2233,884,2289"/>
+<area shape="rect" id="node46" href="$classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates." alt="" coords="688,2313,867,2384"/>
+<area shape="rect" id="node48" href="$classsigc_1_1signal_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal# templates." alt="" coords="677,2409,877,2494"/>
+<area shape="rect" id="node49" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html" title="Convenience wrapper for the numbered sigc::signal# templates." alt="" coords="677,2518,878,2603"/>
+<area shape="rect" id="node51" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="688,2628,867,2699"/>
+</map>
--- /dev/null
+ea8442fc8e8dded4638efd619e708080
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html" title=" " alt="" coords="5,5,175,47"/>
+</map>
--- /dev/null
+2bee845c4dc2008d44faacf315755c2e
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$structsigc_1_1type__trait_3_01T__type_01_6_01_4.html" title=" " alt="" coords="5,5,148,47"/>
+</map>
--- /dev/null
+a67cb34077635588b7b8d73e32587356
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$structsigc_1_1type__trait.html" title=" " alt="" coords="5,5,148,47"/>
+</map>
--- /dev/null
+d6f4f63bc15fb7c171dd7b47c9510a3e
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html" title=" " alt="" coords="5,5,148,47"/>
+</map>
--- /dev/null
+4b652ee78b6b8450bfdd40b306d4d6fb
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$structsigc_1_1type__trait_3_01void_01_4.html" title=" " alt="" coords="5,5,183,32"/>
+</map>
--- /dev/null
+5bb919401bc4e7a32c5d76175ef675ad
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html" title="bound_argument object for a bound argument that is passed by bind() or returned by bind_return() by c..." alt="" coords="5,5,207,61"/>
+</map>
--- /dev/null
+40bfc1139256c60db500859256e6cfdd
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$structsigc_1_1unwrap__reference_3_01const__reference__wrapper_3_01T__type_01_4_01_4.html" title=" " alt="" coords="5,5,207,61"/>
+</map>
--- /dev/null
+fac16e362c2dbcd5d4c0c3549b9dc114
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$structsigc_1_1unwrap__reference_3_01reference__wrapper_3_01T__type_01_4_01_4.html" title=" " alt="" coords="5,5,188,61"/>
+</map>
--- /dev/null
+d2bc55d0802821f2a6689fa67f9b357d
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$structsigc_1_1unwrap__reference_3_01std_1_1reference__wrapper_3_01T__type_01_4_01_4.html" title=" " alt="" coords="5,5,192,61"/>
+</map>
--- /dev/null
+3beab6bf1956c427ac6a8950bf42f73f
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$structsigc_1_1unwrap__reference.html" title=" " alt="" coords="5,5,179,47"/>
+</map>
--- /dev/null
+9be31006f2b8605e1b4234be9fbb154b
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$structsigc_1_1visitor.html" title="sigc::visitor<T_functor>::do_visit_each() performs a functor on each of the targets of a functor." alt="" coords="5,5,193,32"/>
+</map>
--- /dev/null
+79644a5dbf7c365ba038d1689fbc4ced
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$classsigc_1_1volatile__limit__reference.html" title=" " alt="" coords="5,5,161,47"/>
+</map>
--- /dev/null
+005363cfde2ff607cd7fbb09ba7d286b
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$classsigc_1_1volatile__limit__reference.html" title="A volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that,..." alt="" coords="5,5,168,61"/>
+</map>
--- /dev/null
+965db5569a77d528f51a8793b08bab30
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html" title="volatile_limit_reference object for a class that derives from trackable." alt="" coords="5,5,204,47"/>
+</map>
--- /dev/null
+18d5b2b1cc803fcfc712eca01d751eef
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html" title="bound_argument object for a bound argument that is passed by bind() or returned by bind_return() by r..." alt="" coords="5,5,176,61"/>
+</map>
--- /dev/null
+9894c703db7f08c76a8ae4ab2a223d48
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html" title="bound_argument object for a bound argument that is passed by bind() or returned by bind_return() by r..." alt="" coords="5,5,192,61"/>
+</map>
--- /dev/null
+d7da74030b27d7869d3928f7697f9a13
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$classsigc_1_1bound__argument.html" title=" " alt="" coords="5,5,172,47"/>
+</map>
--- /dev/null
+b97e43e8d1693203303ecb029e47f2cd
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$classsigc_1_1bound__argument.html" title=" " alt="" coords="5,5,172,47"/>
+</map>
--- /dev/null
+f1c8ded316b0541e893ebea1fb4f652a
\ No newline at end of file
--- /dev/null
+<map id="Graphical Class Hierarchy" name="Graphical Class Hierarchy">
+<area shape="rect" id="node1" href="$classsigc_1_1bound__argument.html" title="A bound_argument<Foo> object stores a bound (for instance, with sigc::bind(), or sigc::bind_return())..." alt="" coords="5,5,172,47"/>
+</map>
--- /dev/null
+c0dba6290966a77e8868b76effadea3d
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Class Hierarchy</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">Class Hierarchy</div> </div>
+</div><!--header-->
+<div class="contents">
+<div class="textblock">
+<p><a href="hierarchy.html">Go to the textual class hierarchy</a></p>
+</div><table border="0" cellspacing="10" cellpadding="0">
+<tr><td><img src="inherit_graph_0.png" border="0" usemap="#asigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4" alt=""/>
+<map name="asigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4" id="asigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4">
+<area shape="rect" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html" title="Trait that specifies what is the adaptor version of a functor type." alt="" coords="5,5,159,47"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_1.png" border="0" usemap="#asigc_1_1adaptor__trait_3_01T__functor_00_01I__isadaptor_01_4" alt=""/>
+<map name="asigc_1_1adaptor__trait_3_01T__functor_00_01I__isadaptor_01_4" id="asigc_1_1adaptor__trait_3_01T__functor_00_01I__isadaptor_01_4">
+<area shape="rect" href="structsigc_1_1adaptor__trait.html" title="Trait that specifies what is the adaptor version of a functor type." alt="" coords="5,5,199,47"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_2.png" border="0" usemap="#asigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4" alt=""/>
+<map name="asigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4" id="asigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4">
+<area shape="rect" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html" title="Trait that specifies what is the adaptor version of a functor type." alt="" coords="5,5,152,47"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_3.png" border="0" usemap="#asigc_1_1bind__functor_3_01I__location_00_01T__functor_00_01T__type1_00_01T__type2_00_01T__type3_00_01T__type4_00_01T__type5_00_01T__type6_00_01T__type7_01_4" alt=""/>
+<map name="asigc_1_1bind__functor_3_01I__location_00_01T__functor_00_01T__type1_00_01T__type2_00_01T__type3_00_01T__type4_00_01T__type5_00_01T__type6_00_01T__type7_01_4" id="asigc_1_1bind__functor_3_01I__location_00_01T__functor_00_01T__type1_00_01T__type2_00_01T__type3_00_01T__type4_00_01T__type5_00_01T__type6_00_01T__type7_01_4">
+<area shape="rect" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor." alt="" coords="5,5,208,91"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_4.png" border="0" usemap="#asigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4" alt=""/>
+<map name="asigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4" id="asigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4">
+<area shape="rect" href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html" title="bound_argument object for a bound argument that is passed by bind() or returned by bind_return() by c..." alt="" coords="5,5,207,61"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_5.png" border="0" usemap="#asigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4" alt=""/>
+<map name="asigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4" id="asigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4">
+<area shape="rect" href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html" title="bound_argument object for a bound argument that is passed by bind() or returned by bind_return() by r..." alt="" coords="5,5,176,61"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_6.png" border="0" usemap="#asigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4" alt=""/>
+<map name="asigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4" id="asigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4">
+<area shape="rect" href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html" title="bound_argument object for a bound argument that is passed by bind() or returned by bind_return() by r..." alt="" coords="5,5,192,61"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_7.png" border="0" usemap="#asigc_1_1bound__argument_3_01T__bound_01_4" alt=""/>
+<map name="asigc_1_1bound__argument_3_01T__bound_01_4" id="asigc_1_1bound__argument_3_01T__bound_01_4">
+<area shape="rect" href="classsigc_1_1bound__argument.html" title=" " alt="" coords="5,5,172,47"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_8.png" border="0" usemap="#asigc_1_1bound__argument_3_01T__return_01_4" alt=""/>
+<map name="asigc_1_1bound__argument_3_01T__return_01_4" id="asigc_1_1bound__argument_3_01T__return_01_4">
+<area shape="rect" href="classsigc_1_1bound__argument.html" title=" " alt="" coords="5,5,172,47"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_9.png" border="0" usemap="#asigc_1_1bound__argument_3_01T__type_01_4" alt=""/>
+<map name="asigc_1_1bound__argument_3_01T__type_01_4" id="asigc_1_1bound__argument_3_01T__type_01_4">
+<area shape="rect" href="classsigc_1_1bound__argument.html" title="A bound_argument<Foo> object stores a bound (for instance, with sigc::bind(), or sigc::bind_return())..." alt="" coords="5,5,172,47"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_10.png" border="0" usemap="#asigc_1_1bound__argument_3_01T__type1_01_4" alt=""/>
+<map name="asigc_1_1bound__argument_3_01T__type1_01_4" id="asigc_1_1bound__argument_3_01T__type1_01_4">
+<area shape="rect" href="classsigc_1_1bound__argument.html" title=" " alt="" coords="5,5,172,47"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_11.png" border="0" usemap="#asigc_1_1can__deduce__result__type__with__decltype_3_01T__functor_01_4" alt=""/>
+<map name="asigc_1_1can__deduce__result__type__with__decltype_3_01T__functor_01_4" id="asigc_1_1can__deduce__result__type__with__decltype_3_01T__functor_01_4">
+<area shape="rect" href="classsigc_1_1can__deduce__result__type__with__decltype.html" title="Helper class, to determine if decltype() can deduce the result type of a functor." alt="" coords="5,5,184,61"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_12.png" border="0" usemap="#asigc_1_1connection" alt=""/>
+<map name="asigc_1_1connection" id="asigc_1_1connection">
+<area shape="rect" href="structsigc_1_1connection.html" title="Convinience class for safe disconnection." alt="" coords="5,5,132,32"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_13.png" border="0" usemap="#asigc_1_1const__limit__reference_3_01T__obj_01_4" alt=""/>
+<map name="asigc_1_1const__limit__reference_3_01T__obj_01_4" id="asigc_1_1const__limit__reference_3_01T__obj_01_4">
+<area shape="rect" href="classsigc_1_1const__limit__reference.html" title=" " alt="" coords="5,5,203,47"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_14.png" border="0" usemap="#asigc_1_1const__limit__reference_3_01T__type_00_01I__derives__trackable_01_4" alt=""/>
+<map name="asigc_1_1const__limit__reference_3_01T__type_00_01I__derives__trackable_01_4" id="asigc_1_1const__limit__reference_3_01T__type_00_01I__derives__trackable_01_4">
+<area shape="rect" href="classsigc_1_1const__limit__reference.html" title="A const_limit_reference<Foo> object stores a reference (Foo&), but make sure that,..." alt="" coords="5,5,236,47"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_15.png" border="0" usemap="#asigc_1_1const__limit__reference_3_01T__type_00_01true_01_4" alt=""/>
+<map name="asigc_1_1const__limit__reference_3_01T__type_00_01true_01_4" id="asigc_1_1const__limit__reference_3_01T__type_00_01true_01_4">
+<area shape="rect" href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html" title="const_limit_reference object for a class that derives from trackable." alt="" coords="5,5,203,47"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_16.png" border="0" usemap="#asigc_1_1const__limit__reference_3_01T__wrapped_01_4" alt=""/>
+<map name="asigc_1_1const__limit__reference_3_01T__wrapped_01_4" id="asigc_1_1const__limit__reference_3_01T__wrapped_01_4">
+<area shape="rect" href="classsigc_1_1const__limit__reference.html" title=" " alt="" coords="5,5,203,47"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_17.png" border="0" usemap="#asigc_1_1const__reference__wrapper_3_01T__type_01_4" alt=""/>
+<map name="asigc_1_1const__reference__wrapper_3_01T__type_01_4" id="asigc_1_1const__reference__wrapper_3_01T__type_01_4">
+<area shape="rect" href="structsigc_1_1const__reference__wrapper.html" title="Const reference wrapper." alt="" coords="5,5,165,47"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_18.png" border="0" usemap="#asigc_1_1const__volatile__limit__reference_3_01T__obj_01_4" alt=""/>
+<map name="asigc_1_1const__volatile__limit__reference_3_01T__obj_01_4" id="asigc_1_1const__volatile__limit__reference_3_01T__obj_01_4">
+<area shape="rect" href="classsigc_1_1const__volatile__limit__reference.html" title=" " alt="" coords="5,5,199,47"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_19.png" border="0" usemap="#asigc_1_1const__volatile__limit__reference_3_01T__type_00_01I__derives__trackable_01_4" alt=""/>
+<map name="asigc_1_1const__volatile__limit__reference_3_01T__type_00_01I__derives__trackable_01_4" id="asigc_1_1const__volatile__limit__reference_3_01T__type_00_01I__derives__trackable_01_4">
+<area shape="rect" href="classsigc_1_1const__volatile__limit__reference.html" title="A const_volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that,..." alt="" coords="5,5,196,61"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_20.png" border="0" usemap="#asigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4" alt=""/>
+<map name="asigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4" id="asigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4">
+<area shape="rect" href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html" title="const_volatile_limit_reference object for a class that derives from trackable." alt="" coords="5,5,196,61"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_21.png" border="0" usemap="#asigc_1_1deduce__result__type_3_01T__functor_00_01T__args_01_4" alt=""/>
+<map name="asigc_1_1deduce__result__type_3_01T__functor_00_01T__args_01_4" id="asigc_1_1deduce__result__type_3_01T__functor_00_01T__args_01_4">
+<area shape="rect" href="structsigc_1_1deduce__result__type.html" title="Deduce the return type of a functor." alt="" coords="5,5,156,61"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_22.png" border="0" usemap="#asigc_1_1functor__base" alt=""/>
+<map name="asigc_1_1functor__base" id="asigc_1_1functor__base">
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,2311,145,2338"/>
+<area shape="rect" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="227,479,371,506"/>
+<area shape="rect" href="classsigc_1_1const__mem__functor0.html" title="const_mem_functor0 wraps const methods with 0 argument(s)." alt="" coords="202,577,395,619"/>
+<area shape="rect" href="classsigc_1_1const__mem__functor1.html" title="const_mem_functor1 wraps const methods with 1 argument(s)." alt="" coords="198,653,399,695"/>
+<area shape="rect" href="classsigc_1_1const__mem__functor2.html" title="const_mem_functor2 wraps const methods with 2 argument(s)." alt="" coords="202,727,395,783"/>
+<area shape="rect" href="classsigc_1_1const__mem__functor3.html" title="const_mem_functor3 wraps const methods with 3 argument(s)." alt="" coords="202,815,395,871"/>
+<area shape="rect" href="classsigc_1_1const__mem__functor4.html" title="const_mem_functor4 wraps const methods with 4 argument(s)." alt="" coords="202,905,395,961"/>
+<area shape="rect" href="classsigc_1_1const__mem__functor5.html" title="const_mem_functor5 wraps const methods with 5 argument(s)." alt="" coords="202,993,395,1064"/>
+<area shape="rect" href="classsigc_1_1const__mem__functor6.html" title="const_mem_functor6 wraps const methods with 6 argument(s)." alt="" coords="202,1092,395,1163"/>
+<area shape="rect" href="classsigc_1_1const__mem__functor7.html" title="const_mem_functor7 wraps const methods with 7 argument(s)." alt="" coords="202,1187,395,1257"/>
+<area shape="rect" href="classsigc_1_1const__volatile__mem__functor0.html" title="const_volatile_mem_functor0 wraps const volatile methods with 0 argument(s)." alt="" coords="200,1282,397,1338"/>
+<area shape="rect" href="classsigc_1_1const__volatile__mem__functor1.html" title="const_volatile_mem_functor1 wraps const volatile methods with 1 argument(s)." alt="" coords="200,1362,397,1418"/>
+<area shape="rect" href="classsigc_1_1const__volatile__mem__functor2.html" title="const_volatile_mem_functor2 wraps const volatile methods with 2 argument(s)." alt="" coords="200,1442,397,1498"/>
+<area shape="rect" href="classsigc_1_1const__volatile__mem__functor3.html" title="const_volatile_mem_functor3 wraps const volatile methods with 3 argument(s)." alt="" coords="200,1523,397,1593"/>
+<area shape="rect" href="classsigc_1_1const__volatile__mem__functor4.html" title="const_volatile_mem_functor4 wraps const volatile methods with 4 argument(s)." alt="" coords="200,1617,397,1688"/>
+<area shape="rect" href="classsigc_1_1const__volatile__mem__functor5.html" title="const_volatile_mem_functor5 wraps const volatile methods with 5 argument(s)." alt="" coords="200,1712,397,1783"/>
+<area shape="rect" href="classsigc_1_1const__volatile__mem__functor6.html" title="const_volatile_mem_functor6 wraps const volatile methods with 6 argument(s)." alt="" coords="200,1807,397,1893"/>
+<area shape="rect" href="classsigc_1_1const__volatile__mem__functor7.html" title="const_volatile_mem_functor7 wraps const volatile methods with 7 argument(s)." alt="" coords="200,1917,397,2002"/>
+<area shape="rect" href="classsigc_1_1mem__functor0.html" title="mem_functor0 wraps methods with 0 argument(s)." alt="" coords="223,2027,374,2068"/>
+<area shape="rect" href="classsigc_1_1mem__functor1.html" title="mem_functor1 wraps methods with 1 argument(s)." alt="" coords="223,2093,374,2149"/>
+<area shape="rect" href="classsigc_1_1mem__functor2.html" title="mem_functor2 wraps methods with 2 argument(s)." alt="" coords="223,2173,374,2229"/>
+<area shape="rect" href="classsigc_1_1mem__functor3.html" title="mem_functor3 wraps methods with 3 argument(s)." alt="" coords="210,2253,387,2309"/>
+<area shape="rect" href="classsigc_1_1mem__functor4.html" title="mem_functor4 wraps methods with 4 argument(s)." alt="" coords="215,2333,382,2404"/>
+<area shape="rect" href="classsigc_1_1mem__functor5.html" title="mem_functor5 wraps methods with 5 argument(s)." alt="" coords="215,2428,382,2499"/>
+<area shape="rect" href="classsigc_1_1mem__functor6.html" title="mem_functor6 wraps methods with 6 argument(s)." alt="" coords="204,2523,393,2593"/>
+<area shape="rect" href="classsigc_1_1mem__functor7.html" title="mem_functor7 wraps methods with 7 argument(s)." alt="" coords="209,2618,388,2703"/>
+<area shape="rect" href="classsigc_1_1pointer__functor0.html" title="pointer_functor0 wraps existing non-member functions with 0 argument(s)." alt="" coords="217,2728,380,2769"/>
+<area shape="rect" href="classsigc_1_1pointer__functor1.html" title="pointer_functor1 wraps existing non-member functions with 1 argument(s)." alt="" coords="217,2793,380,2835"/>
+<area shape="rect" href="classsigc_1_1pointer__functor2.html" title="pointer_functor2 wraps existing non-member functions with 2 argument(s)." alt="" coords="193,2859,404,2900"/>
+<area shape="rect" href="classsigc_1_1pointer__functor3.html" title="pointer_functor3 wraps existing non-member functions with 3 argument(s)." alt="" coords="204,2925,393,2981"/>
+<area shape="rect" href="classsigc_1_1pointer__functor4.html" title="pointer_functor4 wraps existing non-member functions with 4 argument(s)." alt="" coords="204,3005,393,3061"/>
+<area shape="rect" href="classsigc_1_1pointer__functor5.html" title="pointer_functor5 wraps existing non-member functions with 5 argument(s)." alt="" coords="199,3085,398,3141"/>
+<area shape="rect" href="classsigc_1_1pointer__functor6.html" title="pointer_functor6 wraps existing non-member functions with 6 argument(s)." alt="" coords="204,3165,393,3236"/>
+<area shape="rect" href="classsigc_1_1pointer__functor7.html" title="pointer_functor7 wraps existing non-member functions with 7 argument(s)." alt="" coords="204,3260,393,3331"/>
+<area shape="rect" href="classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="239,3355,358,3382"/>
+<area shape="rect" href="classsigc_1_1volatile__mem__functor0.html" title="volatile_mem_functor0 wraps volatile methods with 0 argument(s)." alt="" coords="221,3409,377,3465"/>
+<area shape="rect" href="classsigc_1_1volatile__mem__functor1.html" title="volatile_mem_functor1 wraps volatile methods with 1 argument(s)." alt="" coords="221,3494,377,3550"/>
+<area shape="rect" href="classsigc_1_1volatile__mem__functor2.html" title="volatile_mem_functor2 wraps volatile methods with 2 argument(s)." alt="" coords="209,3585,389,3641"/>
+<area shape="rect" href="classsigc_1_1volatile__mem__functor3.html" title="volatile_mem_functor3 wraps volatile methods with 3 argument(s)." alt="" coords="214,3687,383,3757"/>
+<area shape="rect" href="classsigc_1_1volatile__mem__functor4.html" title="volatile_mem_functor4 wraps volatile methods with 4 argument(s)." alt="" coords="214,3804,383,3875"/>
+<area shape="rect" href="classsigc_1_1volatile__mem__functor5.html" title="volatile_mem_functor5 wraps volatile methods with 5 argument(s)." alt="" coords="204,3899,393,3969"/>
+<area shape="rect" href="classsigc_1_1volatile__mem__functor6.html" title="volatile_mem_functor6 wraps volatile methods with 6 argument(s)." alt="" coords="209,3994,388,4079"/>
+<area shape="rect" href="classsigc_1_1volatile__mem__functor7.html" title="volatile_mem_functor7 wraps volatile methods with 7 argument(s)." alt="" coords="209,4103,388,4189"/>
+<area shape="rect" href="structsigc_1_1adapts.html" title=" " alt="" coords="477,86,659,113"/>
+<area shape="rect" href="structsigc_1_1adaptor__functor.html" title="Converts an arbitrary functor into an adaptor type." alt="" coords="489,443,647,484"/>
+<area shape="rect" href="structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="473,509,663,535"/>
+<area shape="rect" href="structsigc_1_1compose1__functor.html" title="Adaptor that combines two functors." alt="" coords="751,5,927,47"/>
+<area shape="rect" href="structsigc_1_1compose2__functor.html" title="Adaptor that combines three functors." alt="" coords="751,71,927,127"/>
+<area shape="rect" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Adaptor that binds an argument to the wrapped functor." alt="" coords="748,151,929,207"/>
+<area shape="rect" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Adaptor that binds 1 argument(s) to the wrapped functor." alt="" coords="749,231,928,287"/>
+<area shape="rect" href="structsigc_1_1bind__return__functor.html" title="Adaptor that fixes the return value of the wrapped functor." alt="" coords="747,312,930,353"/>
+<area shape="rect" href="structsigc_1_1exception__catch__functor.html" title=" " alt="" coords="755,378,922,434"/>
+<area shape="rect" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html" title=" " alt="" coords="757,458,920,514"/>
+<area shape="rect" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html" title="Adaptor that adds a dummy parameter to the wrapped functor." alt="" coords="770,539,907,580"/>
+<area shape="rect" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html" title="Adaptor that adds a dummy parameter to the wrapped functor." alt="" coords="770,604,907,645"/>
+<area shape="rect" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor." alt="" coords="732,669,945,740"/>
+<area shape="rect" href="structsigc_1_1retype__return__functor.html" title="Adaptor that performs a C-style cast on the return value of a functor." alt="" coords="765,765,913,821"/>
+<area shape="rect" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html" title="Adaptor that performs a C-style cast on the return value of a functor." alt="" coords="737,845,940,887"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object." alt="" coords="750,911,927,952"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor2.html" title="track_obj_functor2 wraps a functor and stores 2 references to trackable objects." alt="" coords="999,717,1213,759"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor3.html" title="track_obj_functor3 wraps a functor and stores 3 references to trackable objects." alt="" coords="1017,783,1195,839"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor4.html" title="track_obj_functor4 wraps a functor and stores 4 references to trackable objects." alt="" coords="1017,863,1195,919"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor5.html" title="track_obj_functor5 wraps a functor and stores 5 references to trackable objects." alt="" coords="993,943,1219,999"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor6.html" title="track_obj_functor6 wraps a functor and stores 6 references to trackable objects." alt="" coords="1017,1024,1195,1095"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor7.html" title="track_obj_functor7 wraps a functor and stores 7 references to trackable objects." alt="" coords="1017,1119,1195,1189"/>
+<area shape="rect" href="classsigc_1_1bound__const__mem__functor0.html" title="bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance." alt="" coords="479,559,657,615"/>
+<area shape="rect" href="classsigc_1_1bound__const__mem__functor1.html" title="bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance." alt="" coords="479,639,657,695"/>
+<area shape="rect" href="classsigc_1_1bound__const__mem__functor2.html" title="bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance." alt="" coords="478,719,658,775"/>
+<area shape="rect" href="classsigc_1_1bound__const__mem__functor3.html" title="bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance." alt="" coords="479,800,657,871"/>
+<area shape="rect" href="classsigc_1_1bound__const__mem__functor4.html" title="bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance." alt="" coords="479,895,657,965"/>
+<area shape="rect" href="classsigc_1_1bound__const__mem__functor5.html" title="bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance." alt="" coords="473,989,663,1060"/>
+<area shape="rect" href="classsigc_1_1bound__const__mem__functor6.html" title="bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance." alt="" coords="479,1085,657,1170"/>
+<area shape="rect" href="classsigc_1_1bound__const__mem__functor7.html" title="bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance." alt="" coords="479,1194,657,1279"/>
+<area shape="rect" href="classsigc_1_1bound__const__volatile__mem__functor0.html" title="bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object..." alt="" coords="469,1303,667,1359"/>
+<area shape="rect" href="classsigc_1_1bound__const__volatile__mem__functor1.html" title="bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object..." alt="" coords="469,1383,667,1439"/>
+<area shape="rect" href="classsigc_1_1bound__const__volatile__mem__functor2.html" title="bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object..." alt="" coords="469,1463,667,1519"/>
+<area shape="rect" href="classsigc_1_1bound__const__volatile__mem__functor3.html" title="bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object..." alt="" coords="452,1543,684,1599"/>
+<area shape="rect" href="classsigc_1_1bound__const__volatile__mem__functor4.html" title="bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object..." alt="" coords="469,1624,667,1695"/>
+<area shape="rect" href="classsigc_1_1bound__const__volatile__mem__functor5.html" title="bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object..." alt="" coords="469,1719,667,1789"/>
+<area shape="rect" href="classsigc_1_1bound__const__volatile__mem__functor6.html" title="bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object..." alt="" coords="453,1815,683,1885"/>
+<area shape="rect" href="classsigc_1_1bound__const__volatile__mem__functor7.html" title="bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object..." alt="" coords="459,1917,677,2002"/>
+<area shape="rect" href="classsigc_1_1bound__mem__functor0.html" title="bound_mem_functor0 encapsulates a method with 0 arguments and an object instance." alt="" coords="469,2027,667,2068"/>
+<area shape="rect" href="classsigc_1_1bound__mem__functor1.html" title="bound_mem_functor1 encapsulates a method with 1 arguments and an object instance." alt="" coords="467,2100,669,2141"/>
+<area shape="rect" href="classsigc_1_1bound__mem__functor2.html" title="bound_mem_functor2 encapsulates a method with 2 arguments and an object instance." alt="" coords="469,2173,667,2229"/>
+<area shape="rect" href="classsigc_1_1bound__mem__functor3.html" title="bound_mem_functor3 encapsulates a method with 3 arguments and an object instance." alt="" coords="469,2253,667,2309"/>
+<area shape="rect" href="classsigc_1_1bound__mem__functor4.html" title="bound_mem_functor4 encapsulates a method with 4 arguments and an object instance." alt="" coords="469,2341,667,2397"/>
+<area shape="rect" href="classsigc_1_1bound__mem__functor5.html" title="bound_mem_functor5 encapsulates a method with 5 arguments and an object instance." alt="" coords="469,2428,667,2499"/>
+<area shape="rect" href="classsigc_1_1bound__mem__functor6.html" title="bound_mem_functor6 encapsulates a method with 6 arguments and an object instance." alt="" coords="469,2523,667,2593"/>
+<area shape="rect" href="classsigc_1_1bound__mem__functor7.html" title="bound_mem_functor7 encapsulates a method with 7 arguments and an object instance." alt="" coords="469,2625,667,2696"/>
+<area shape="rect" href="classsigc_1_1slot7.html" title=" " alt="" coords="487,2723,649,2779"/>
+<area shape="rect" href="classsigc_1_1slot0.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="482,2810,654,2837"/>
+<area shape="rect" href="classsigc_1_1slot1.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="487,2875,649,2916"/>
+<area shape="rect" href="classsigc_1_1slot2.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="487,2951,649,2992"/>
+<area shape="rect" href="classsigc_1_1slot3.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="473,3023,663,3064"/>
+<area shape="rect" href="classsigc_1_1slot4.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="479,3089,657,3145"/>
+<area shape="rect" href="classsigc_1_1slot5.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="479,3169,657,3225"/>
+<area shape="rect" href="classsigc_1_1slot6.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="473,3249,663,3305"/>
+<area shape="rect" href="classsigc_1_1slot7.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="479,3329,657,3400"/>
+<area shape="rect" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html" title="Converts an arbitrary functor to a unified type which is opaque." alt="" coords="493,3424,643,3465"/>
+<area shape="rect" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates." alt="" coords="749,2684,928,2755"/>
+<area shape="rect" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot0 template." alt="" coords="762,2779,915,2835"/>
+<area shape="rect" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot1 template." alt="" coords="762,2859,915,2915"/>
+<area shape="rect" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot2 template." alt="" coords="762,2939,915,2995"/>
+<area shape="rect" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot3 template." alt="" coords="749,3019,928,3075"/>
+<area shape="rect" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot4 template." alt="" coords="749,3099,928,3155"/>
+<area shape="rect" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot5 template." alt="" coords="746,3179,931,3235"/>
+<area shape="rect" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::slot6 template." alt="" coords="732,3259,945,3315"/>
+<area shape="rect" href="classsigc_1_1bound__volatile__mem__functor0.html" title="bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance." alt="" coords="469,3490,667,3546"/>
+<area shape="rect" href="classsigc_1_1bound__volatile__mem__functor1.html" title="bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance." alt="" coords="469,3570,667,3626"/>
+<area shape="rect" href="classsigc_1_1bound__volatile__mem__functor2.html" title="bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance." alt="" coords="469,3650,667,3706"/>
+<area shape="rect" href="classsigc_1_1bound__volatile__mem__functor3.html" title="bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance." alt="" coords="469,3731,667,3801"/>
+<area shape="rect" href="classsigc_1_1bound__volatile__mem__functor4.html" title="bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance." alt="" coords="469,3825,667,3896"/>
+<area shape="rect" href="classsigc_1_1bound__volatile__mem__functor5.html" title="bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance." alt="" coords="469,3920,667,3991"/>
+<area shape="rect" href="classsigc_1_1bound__volatile__mem__functor6.html" title="bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance." alt="" coords="469,4015,667,4101"/>
+<area shape="rect" href="classsigc_1_1bound__volatile__mem__functor7.html" title="bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance." alt="" coords="469,4125,667,4210"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_23.png" border="0" usemap="#asigc_1_1functor__trait_3_01T__functor_00_01I__derives__functor__base_00_01I__can__use__decltype_01_4" alt=""/>
+<map name="asigc_1_1functor__trait_3_01T__functor_00_01I__derives__functor__base_00_01I__can__use__decltype_01_4" id="asigc_1_1functor__trait_3_01T__functor_00_01I__derives__functor__base_00_01I__can__use__decltype_01_4">
+<area shape="rect" href="structsigc_1_1functor__trait.html" title="Trait that specifies the return type of any type." alt="" coords="5,5,191,76"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_24.png" border="0" usemap="#asigc_1_1hide__functor_3_01I__location_00_01T__functor_01_4" alt=""/>
+<map name="asigc_1_1hide__functor_3_01I__location_00_01T__functor_01_4" id="asigc_1_1hide__functor_3_01I__location_00_01T__functor_01_4">
+<area shape="rect" href="structsigc_1_1hide__functor.html" title="Adaptor that adds a dummy parameter to the wrapped functor." alt="" coords="5,5,189,47"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_25.png" border="0" usemap="#asigc_1_1limit__reference_3_01T__obj_01_4" alt=""/>
+<map name="asigc_1_1limit__reference_3_01T__obj_01_4" id="asigc_1_1limit__reference_3_01T__obj_01_4">
+<area shape="rect" href="classsigc_1_1limit__reference.html" title=" " alt="" coords="5,5,160,47"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_26.png" border="0" usemap="#asigc_1_1limit__reference_3_01T__type_00_01I__derives__trackable_01_4" alt=""/>
+<map name="asigc_1_1limit__reference_3_01T__type_00_01I__derives__trackable_01_4" id="asigc_1_1limit__reference_3_01T__type_00_01I__derives__trackable_01_4">
+<area shape="rect" href="classsigc_1_1limit__reference.html" title="A limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from sig..." alt="" coords="5,5,236,47"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_27.png" border="0" usemap="#asigc_1_1limit__reference_3_01T__type_00_01true_01_4" alt=""/>
+<map name="asigc_1_1limit__reference_3_01T__type_00_01true_01_4" id="asigc_1_1limit__reference_3_01T__type_00_01true_01_4">
+<area shape="rect" href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html" title="limit_reference object for a class that derives from trackable." alt="" coords="5,5,160,47"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_28.png" border="0" usemap="#asigc_1_1limit__reference_3_01T__wrapped_01_4" alt=""/>
+<map name="asigc_1_1limit__reference_3_01T__wrapped_01_4" id="asigc_1_1limit__reference_3_01T__wrapped_01_4">
+<area shape="rect" href="classsigc_1_1limit__reference.html" title=" " alt="" coords="5,5,160,47"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_29.png" border="0" usemap="#asigc_1_1nil" alt=""/>
+<map name="asigc_1_1nil" id="asigc_1_1nil">
+<area shape="rect" href="structsigc_1_1nil.html" title="nil struct type." alt="" coords="5,5,77,32"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_30.png" border="0" usemap="#asigc_1_1reference__wrapper_3_01T__type_01_4" alt=""/>
+<map name="asigc_1_1reference__wrapper_3_01T__type_01_4" id="asigc_1_1reference__wrapper_3_01T__type_01_4">
+<area shape="rect" href="structsigc_1_1reference__wrapper.html" title="Reference wrapper." alt="" coords="5,5,184,47"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_31.png" border="0" usemap="#asigc_1_1slot__const__iterator_3_01T__slot_01_4" alt=""/>
+<map name="asigc_1_1slot__const__iterator_3_01T__slot_01_4" id="asigc_1_1slot__const__iterator_3_01T__slot_01_4">
+<area shape="rect" href="structsigc_1_1slot__const__iterator.html" title="STL-style const iterator for slot_list." alt="" coords="5,5,183,47"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_32.png" border="0" usemap="#asigc_1_1slot__iterator_3_01T__slot_01_4" alt=""/>
+<map name="asigc_1_1slot__iterator_3_01T__slot_01_4" id="asigc_1_1slot__iterator_3_01T__slot_01_4">
+<area shape="rect" href="structsigc_1_1slot__iterator.html" title="STL-style iterator for slot_list." alt="" coords="5,5,140,47"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_33.png" border="0" usemap="#asigc_1_1slot__list_3_01T__slot_01_4" alt=""/>
+<map name="asigc_1_1slot__list_3_01T__slot_01_4" id="asigc_1_1slot__list_3_01T__slot_01_4">
+<area shape="rect" href="structsigc_1_1slot__list.html" title="STL-style list interface for sigc::signal#." alt="" coords="5,5,136,47"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_34.png" border="0" usemap="#asigc_1_1trackable" alt=""/>
+<map name="asigc_1_1trackable" id="asigc_1_1trackable">
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="5,1850,121,1877"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="169,1850,303,1877"/>
+<area shape="rect" href="classsigc_1_1signal0.html" title=" " alt="" coords="383,85,559,127"/>
+<area shape="rect" href="classsigc_1_1signal0.html" title=" " alt="" coords="383,224,559,265"/>
+<area shape="rect" href="classsigc_1_1signal1.html" title=" " alt="" coords="383,371,559,412"/>
+<area shape="rect" href="classsigc_1_1signal1.html" title=" " alt="" coords="377,539,566,580"/>
+<area shape="rect" href="classsigc_1_1signal2.html" title=" " alt="" coords="351,715,592,756"/>
+<area shape="rect" href="classsigc_1_1signal2.html" title=" " alt="" coords="383,868,559,909"/>
+<area shape="rect" href="classsigc_1_1signal3.html" title=" " alt="" coords="382,1029,561,1085"/>
+<area shape="rect" href="classsigc_1_1signal3.html" title=" " alt="" coords="382,1182,561,1238"/>
+<area shape="rect" href="classsigc_1_1signal4.html" title=" " alt="" coords="382,1342,561,1398"/>
+<area shape="rect" href="classsigc_1_1signal4.html" title=" " alt="" coords="377,1525,566,1581"/>
+<area shape="rect" href="classsigc_1_1signal5.html" title=" " alt="" coords="351,1667,592,1723"/>
+<area shape="rect" href="classsigc_1_1signal5.html" title=" " alt="" coords="382,1747,561,1803"/>
+<area shape="rect" href="classsigc_1_1signal6.html" title=" " alt="" coords="382,1828,561,1899"/>
+<area shape="rect" href="classsigc_1_1signal6.html" title=" " alt="" coords="365,1923,578,1979"/>
+<area shape="rect" href="classsigc_1_1signal7.html" title=" " alt="" coords="383,2003,559,2059"/>
+<area shape="rect" href="classsigc_1_1signal7.html" title=" " alt="" coords="377,2084,566,2155"/>
+<area shape="rect" href="classsigc_1_1signal7.html" title=" " alt="" coords="382,2179,561,2249"/>
+<area shape="rect" href="classsigc_1_1signal0.html" title="Signal declaration." alt="" coords="383,2273,559,2315"/>
+<area shape="rect" href="classsigc_1_1signal1.html" title="Signal declaration." alt="" coords="377,2339,566,2380"/>
+<area shape="rect" href="classsigc_1_1signal2.html" title="Signal declaration." alt="" coords="351,2404,592,2445"/>
+<area shape="rect" href="classsigc_1_1signal3.html" title="Signal declaration." alt="" coords="382,2470,561,2526"/>
+<area shape="rect" href="classsigc_1_1signal4.html" title="Signal declaration." alt="" coords="377,2550,566,2606"/>
+<area shape="rect" href="classsigc_1_1signal5.html" title="Signal declaration." alt="" coords="351,2630,592,2686"/>
+<area shape="rect" href="classsigc_1_1signal6.html" title="Signal declaration." alt="" coords="382,2711,561,2781"/>
+<area shape="rect" href="classsigc_1_1signal7.html" title="Signal declaration." alt="" coords="377,2805,566,2876"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal0 template." alt="" coords="647,5,908,47"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal0 template." alt="" coords="691,71,864,141"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="685,166,870,193"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal0 template." alt="" coords="693,217,861,273"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="695,297,859,339"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal1 template." alt="" coords="693,363,861,419"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal1 template." alt="" coords="688,443,867,499"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal1 template." alt="" coords="679,524,876,595"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal2 template." alt="" coords="662,619,893,675"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal2 template." alt="" coords="661,700,893,771"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="695,795,859,836"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal2 template." alt="" coords="693,861,861,917"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal3 template." alt="" coords="652,941,903,997"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html" title="Convenience wrapper for the numbered sigc::signal3 template." alt="" coords="667,1021,888,1092"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="682,1116,873,1157"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal3 template." alt="" coords="688,1182,867,1238"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="688,1262,867,1318"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal4 template." alt="" coords="688,1342,867,1398"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal4 template." alt="" coords="683,1423,872,1493"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html" title="Convenience wrapper for the numbered sigc::signal4 template." alt="" coords="657,1517,897,1588"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal5 template." alt="" coords="662,1612,893,1683"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html" title="Convenience wrapper for the numbered sigc::signal5 template." alt="" coords="650,1707,905,1777"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="688,1802,867,1858"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal5 template." alt="" coords="685,1882,870,1938"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html" title="Convenience wrapper for the numbered sigc::signal6 template." alt="" coords="652,1963,903,2033"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html" title="Convenience wrapper for the numbered sigc::signal6 template." alt="" coords="640,2057,915,2128"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="682,2153,873,2209"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal6 template." alt="" coords="671,2233,884,2289"/>
+<area shape="rect" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates." alt="" coords="688,2313,867,2384"/>
+<area shape="rect" href="classsigc_1_1signal_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal# templates." alt="" coords="677,2409,877,2494"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html" title="Convenience wrapper for the numbered sigc::signal# templates." alt="" coords="677,2518,878,2603"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="688,2628,867,2699"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_35.png" border="0" usemap="#asigc_1_1type__trait_3_01const_01T__type_01_6_01_4" alt=""/>
+<map name="asigc_1_1type__trait_3_01const_01T__type_01_6_01_4" id="asigc_1_1type__trait_3_01const_01T__type_01_6_01_4">
+<area shape="rect" href="structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html" title=" " alt="" coords="5,5,175,47"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_36.png" border="0" usemap="#asigc_1_1type__trait_3_01T__type_01_6_01_4" alt=""/>
+<map name="asigc_1_1type__trait_3_01T__type_01_6_01_4" id="asigc_1_1type__trait_3_01T__type_01_6_01_4">
+<area shape="rect" href="structsigc_1_1type__trait_3_01T__type_01_6_01_4.html" title=" " alt="" coords="5,5,148,47"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_37.png" border="0" usemap="#asigc_1_1type__trait_3_01T__type_01_4" alt=""/>
+<map name="asigc_1_1type__trait_3_01T__type_01_4" id="asigc_1_1type__trait_3_01T__type_01_4">
+<area shape="rect" href="structsigc_1_1type__trait.html" title=" " alt="" coords="5,5,148,47"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_38.png" border="0" usemap="#asigc_1_1type__trait_3_01T__type_0fN_0e_4" alt=""/>
+<map name="asigc_1_1type__trait_3_01T__type_0fN_0e_4" id="asigc_1_1type__trait_3_01T__type_0fN_0e_4">
+<area shape="rect" href="structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html" title=" " alt="" coords="5,5,148,47"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_39.png" border="0" usemap="#asigc_1_1type__trait_3_01void_01_4" alt=""/>
+<map name="asigc_1_1type__trait_3_01void_01_4" id="asigc_1_1type__trait_3_01void_01_4">
+<area shape="rect" href="structsigc_1_1type__trait_3_01void_01_4.html" title=" " alt="" coords="5,5,183,32"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_40.png" border="0" usemap="#asigc_1_1unwrap__reference_3_01const__reference__wrapper_3_01T__type_01_4_01_4" alt=""/>
+<map name="asigc_1_1unwrap__reference_3_01const__reference__wrapper_3_01T__type_01_4_01_4" id="asigc_1_1unwrap__reference_3_01const__reference__wrapper_3_01T__type_01_4_01_4">
+<area shape="rect" href="structsigc_1_1unwrap__reference_3_01const__reference__wrapper_3_01T__type_01_4_01_4.html" title=" " alt="" coords="5,5,207,61"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_41.png" border="0" usemap="#asigc_1_1unwrap__reference_3_01reference__wrapper_3_01T__type_01_4_01_4" alt=""/>
+<map name="asigc_1_1unwrap__reference_3_01reference__wrapper_3_01T__type_01_4_01_4" id="asigc_1_1unwrap__reference_3_01reference__wrapper_3_01T__type_01_4_01_4">
+<area shape="rect" href="structsigc_1_1unwrap__reference_3_01reference__wrapper_3_01T__type_01_4_01_4.html" title=" " alt="" coords="5,5,188,61"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_42.png" border="0" usemap="#asigc_1_1unwrap__reference_3_01std_1_1reference__wrapper_3_01T__type_01_4_01_4" alt=""/>
+<map name="asigc_1_1unwrap__reference_3_01std_1_1reference__wrapper_3_01T__type_01_4_01_4" id="asigc_1_1unwrap__reference_3_01std_1_1reference__wrapper_3_01T__type_01_4_01_4">
+<area shape="rect" href="structsigc_1_1unwrap__reference_3_01std_1_1reference__wrapper_3_01T__type_01_4_01_4.html" title=" " alt="" coords="5,5,192,61"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_43.png" border="0" usemap="#asigc_1_1unwrap__reference_3_01T__type_01_4" alt=""/>
+<map name="asigc_1_1unwrap__reference_3_01T__type_01_4" id="asigc_1_1unwrap__reference_3_01T__type_01_4">
+<area shape="rect" href="structsigc_1_1unwrap__reference.html" title=" " alt="" coords="5,5,179,47"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_44.png" border="0" usemap="#asigc_1_1visitor_3_01T__functor_01_4" alt=""/>
+<map name="asigc_1_1visitor_3_01T__functor_01_4" id="asigc_1_1visitor_3_01T__functor_01_4">
+<area shape="rect" href="structsigc_1_1visitor.html" title="sigc::visitor<T_functor>::do_visit_each() performs a functor on each of the targets of a functor." alt="" coords="5,5,193,32"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_45.png" border="0" usemap="#asigc_1_1volatile__limit__reference_3_01T__obj_01_4" alt=""/>
+<map name="asigc_1_1volatile__limit__reference_3_01T__obj_01_4" id="asigc_1_1volatile__limit__reference_3_01T__obj_01_4">
+<area shape="rect" href="classsigc_1_1volatile__limit__reference.html" title=" " alt="" coords="5,5,161,47"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_46.png" border="0" usemap="#asigc_1_1volatile__limit__reference_3_01T__type_00_01I__derives__trackable_01_4" alt=""/>
+<map name="asigc_1_1volatile__limit__reference_3_01T__type_00_01I__derives__trackable_01_4" id="asigc_1_1volatile__limit__reference_3_01T__type_00_01I__derives__trackable_01_4">
+<area shape="rect" href="classsigc_1_1volatile__limit__reference.html" title="A volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that,..." alt="" coords="5,5,168,61"/>
+</map>
+</td></tr>
+<tr><td><img src="inherit_graph_47.png" border="0" usemap="#asigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4" alt=""/>
+<map name="asigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4" id="asigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4">
+<area shape="rect" href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html" title="volatile_limit_reference object for a class that derives from trackable." alt="" coords="5,5,204,47"/>
+</map>
+</td></tr>
+</table>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+/*! jQuery v3.4.1 | (c) JS Foundation and other contributors | jquery.org/license */
+!function(e,t){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return t(e)}:t(e)}("undefined"!=typeof window?window:this,function(C,e){"use strict";var t=[],E=C.document,r=Object.getPrototypeOf,s=t.slice,g=t.concat,u=t.push,i=t.indexOf,n={},o=n.toString,v=n.hasOwnProperty,a=v.toString,l=a.call(Object),y={},m=function(e){return"function"==typeof e&&"number"!=typeof e.nodeType},x=function(e){return null!=e&&e===e.window},c={type:!0,src:!0,nonce:!0,noModule:!0};function b(e,t,n){var r,i,o=(n=n||E).createElement("script");if(o.text=e,t)for(r in c)(i=t[r]||t.getAttribute&&t.getAttribute(r))&&o.setAttribute(r,i);n.head.appendChild(o).parentNode.removeChild(o)}function w(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?n[o.call(e)]||"object":typeof e}var f="3.4.1",k=function(e,t){return new k.fn.init(e,t)},p=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;function d(e){var t=!!e&&"length"in e&&e.length,n=w(e);return!m(e)&&!x(e)&&("array"===n||0===t||"number"==typeof t&&0<t&&t-1 in e)}k.fn=k.prototype={jquery:f,constructor:k,length:0,toArray:function(){return s.call(this)},get:function(e){return null==e?s.call(this):e<0?this[e+this.length]:this[e]},pushStack:function(e){var t=k.merge(this.constructor(),e);return t.prevObject=this,t},each:function(e){return k.each(this,e)},map:function(n){return this.pushStack(k.map(this,function(e,t){return n.call(e,t,e)}))},slice:function(){return this.pushStack(s.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},eq:function(e){var t=this.length,n=+e+(e<0?t:0);return this.pushStack(0<=n&&n<t?[this[n]]:[])},end:function(){return this.prevObject||this.constructor()},push:u,sort:t.sort,splice:t.splice},k.extend=k.fn.extend=function(){var e,t,n,r,i,o,a=arguments[0]||{},s=1,u=arguments.length,l=!1;for("boolean"==typeof a&&(l=a,a=arguments[s]||{},s++),"object"==typeof a||m(a)||(a={}),s===u&&(a=this,s--);s<u;s++)if(null!=(e=arguments[s]))for(t in e)r=e[t],"__proto__"!==t&&a!==r&&(l&&r&&(k.isPlainObject(r)||(i=Array.isArray(r)))?(n=a[t],o=i&&!Array.isArray(n)?[]:i||k.isPlainObject(n)?n:{},i=!1,a[t]=k.extend(l,o,r)):void 0!==r&&(a[t]=r));return a},k.extend({expando:"jQuery"+(f+Math.random()).replace(/\D/g,""),isReady:!0,error:function(e){throw new Error(e)},noop:function(){},isPlainObject:function(e){var t,n;return!(!e||"[object Object]"!==o.call(e))&&(!(t=r(e))||"function"==typeof(n=v.call(t,"constructor")&&t.constructor)&&a.call(n)===l)},isEmptyObject:function(e){var t;for(t in e)return!1;return!0},globalEval:function(e,t){b(e,{nonce:t&&t.nonce})},each:function(e,t){var n,r=0;if(d(e)){for(n=e.length;r<n;r++)if(!1===t.call(e[r],r,e[r]))break}else for(r in e)if(!1===t.call(e[r],r,e[r]))break;return e},trim:function(e){return null==e?"":(e+"").replace(p,"")},makeArray:function(e,t){var n=t||[];return null!=e&&(d(Object(e))?k.merge(n,"string"==typeof e?[e]:e):u.call(n,e)),n},inArray:function(e,t,n){return null==t?-1:i.call(t,e,n)},merge:function(e,t){for(var n=+t.length,r=0,i=e.length;r<n;r++)e[i++]=t[r];return e.length=i,e},grep:function(e,t,n){for(var r=[],i=0,o=e.length,a=!n;i<o;i++)!t(e[i],i)!==a&&r.push(e[i]);return r},map:function(e,t,n){var r,i,o=0,a=[];if(d(e))for(r=e.length;o<r;o++)null!=(i=t(e[o],o,n))&&a.push(i);else for(o in e)null!=(i=t(e[o],o,n))&&a.push(i);return g.apply([],a)},guid:1,support:y}),"function"==typeof Symbol&&(k.fn[Symbol.iterator]=t[Symbol.iterator]),k.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "),function(e,t){n["[object "+t+"]"]=t.toLowerCase()});var h=function(n){var e,d,b,o,i,h,f,g,w,u,l,T,C,a,E,v,s,c,y,k="sizzle"+1*new Date,m=n.document,S=0,r=0,p=ue(),x=ue(),N=ue(),A=ue(),D=function(e,t){return e===t&&(l=!0),0},j={}.hasOwnProperty,t=[],q=t.pop,L=t.push,H=t.push,O=t.slice,P=function(e,t){for(var n=0,r=e.length;n<r;n++)if(e[n]===t)return n;return-1},R="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",M="[\\x20\\t\\r\\n\\f]",I="(?:\\\\.|[\\w-]|[^\0-\\xa0])+",W="\\["+M+"*("+I+")(?:"+M+"*([*^$|!~]?=)"+M+"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|("+I+"))|)"+M+"*\\]",$=":("+I+")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|"+W+")*)|.*)\\)|)",F=new RegExp(M+"+","g"),B=new RegExp("^"+M+"+|((?:^|[^\\\\])(?:\\\\.)*)"+M+"+$","g"),_=new RegExp("^"+M+"*,"+M+"*"),z=new RegExp("^"+M+"*([>+~]|"+M+")"+M+"*"),U=new RegExp(M+"|>"),X=new RegExp($),V=new RegExp("^"+I+"$"),G={ID:new RegExp("^#("+I+")"),CLASS:new RegExp("^\\.("+I+")"),TAG:new RegExp("^("+I+"|[*])"),ATTR:new RegExp("^"+W),PSEUDO:new RegExp("^"+$),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+M+"*(even|odd|(([+-]|)(\\d*)n|)"+M+"*(?:([+-]|)"+M+"*(\\d+)|))"+M+"*\\)|)","i"),bool:new RegExp("^(?:"+R+")$","i"),needsContext:new RegExp("^"+M+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+M+"*((?:-\\d)?\\d*)"+M+"*\\)|)(?=[^-]|$)","i")},Y=/HTML$/i,Q=/^(?:input|select|textarea|button)$/i,J=/^h\d$/i,K=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ee=/[+~]/,te=new RegExp("\\\\([\\da-f]{1,6}"+M+"?|("+M+")|.)","ig"),ne=function(e,t,n){var r="0x"+t-65536;return r!=r||n?t:r<0?String.fromCharCode(r+65536):String.fromCharCode(r>>10|55296,1023&r|56320)},re=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ie=function(e,t){return t?"\0"===e?"\ufffd":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},oe=function(){T()},ae=be(function(e){return!0===e.disabled&&"fieldset"===e.nodeName.toLowerCase()},{dir:"parentNode",next:"legend"});try{H.apply(t=O.call(m.childNodes),m.childNodes),t[m.childNodes.length].nodeType}catch(e){H={apply:t.length?function(e,t){L.apply(e,O.call(t))}:function(e,t){var n=e.length,r=0;while(e[n++]=t[r++]);e.length=n-1}}}function se(t,e,n,r){var i,o,a,s,u,l,c,f=e&&e.ownerDocument,p=e?e.nodeType:9;if(n=n||[],"string"!=typeof t||!t||1!==p&&9!==p&&11!==p)return n;if(!r&&((e?e.ownerDocument||e:m)!==C&&T(e),e=e||C,E)){if(11!==p&&(u=Z.exec(t)))if(i=u[1]){if(9===p){if(!(a=e.getElementById(i)))return n;if(a.id===i)return n.push(a),n}else if(f&&(a=f.getElementById(i))&&y(e,a)&&a.id===i)return n.push(a),n}else{if(u[2])return H.apply(n,e.getElementsByTagName(t)),n;if((i=u[3])&&d.getElementsByClassName&&e.getElementsByClassName)return H.apply(n,e.getElementsByClassName(i)),n}if(d.qsa&&!A[t+" "]&&(!v||!v.test(t))&&(1!==p||"object"!==e.nodeName.toLowerCase())){if(c=t,f=e,1===p&&U.test(t)){(s=e.getAttribute("id"))?s=s.replace(re,ie):e.setAttribute("id",s=k),o=(l=h(t)).length;while(o--)l[o]="#"+s+" "+xe(l[o]);c=l.join(","),f=ee.test(t)&&ye(e.parentNode)||e}try{return H.apply(n,f.querySelectorAll(c)),n}catch(e){A(t,!0)}finally{s===k&&e.removeAttribute("id")}}}return g(t.replace(B,"$1"),e,n,r)}function ue(){var r=[];return function e(t,n){return r.push(t+" ")>b.cacheLength&&delete e[r.shift()],e[t+" "]=n}}function le(e){return e[k]=!0,e}function ce(e){var t=C.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function fe(e,t){var n=e.split("|"),r=n.length;while(r--)b.attrHandle[n[r]]=t}function pe(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)while(n=n.nextSibling)if(n===t)return-1;return e?1:-1}function de(t){return function(e){return"input"===e.nodeName.toLowerCase()&&e.type===t}}function he(n){return function(e){var t=e.nodeName.toLowerCase();return("input"===t||"button"===t)&&e.type===n}}function ge(t){return function(e){return"form"in e?e.parentNode&&!1===e.disabled?"label"in e?"label"in e.parentNode?e.parentNode.disabled===t:e.disabled===t:e.isDisabled===t||e.isDisabled!==!t&&ae(e)===t:e.disabled===t:"label"in e&&e.disabled===t}}function ve(a){return le(function(o){return o=+o,le(function(e,t){var n,r=a([],e.length,o),i=r.length;while(i--)e[n=r[i]]&&(e[n]=!(t[n]=e[n]))})})}function ye(e){return e&&"undefined"!=typeof e.getElementsByTagName&&e}for(e in d=se.support={},i=se.isXML=function(e){var t=e.namespaceURI,n=(e.ownerDocument||e).documentElement;return!Y.test(t||n&&n.nodeName||"HTML")},T=se.setDocument=function(e){var t,n,r=e?e.ownerDocument||e:m;return r!==C&&9===r.nodeType&&r.documentElement&&(a=(C=r).documentElement,E=!i(C),m!==C&&(n=C.defaultView)&&n.top!==n&&(n.addEventListener?n.addEventListener("unload",oe,!1):n.attachEvent&&n.attachEvent("onunload",oe)),d.attributes=ce(function(e){return e.className="i",!e.getAttribute("className")}),d.getElementsByTagName=ce(function(e){return e.appendChild(C.createComment("")),!e.getElementsByTagName("*").length}),d.getElementsByClassName=K.test(C.getElementsByClassName),d.getById=ce(function(e){return a.appendChild(e).id=k,!C.getElementsByName||!C.getElementsByName(k).length}),d.getById?(b.filter.ID=function(e){var t=e.replace(te,ne);return function(e){return e.getAttribute("id")===t}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n=t.getElementById(e);return n?[n]:[]}}):(b.filter.ID=function(e){var n=e.replace(te,ne);return function(e){var t="undefined"!=typeof e.getAttributeNode&&e.getAttributeNode("id");return t&&t.value===n}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n,r,i,o=t.getElementById(e);if(o){if((n=o.getAttributeNode("id"))&&n.value===e)return[o];i=t.getElementsByName(e),r=0;while(o=i[r++])if((n=o.getAttributeNode("id"))&&n.value===e)return[o]}return[]}}),b.find.TAG=d.getElementsByTagName?function(e,t){return"undefined"!=typeof t.getElementsByTagName?t.getElementsByTagName(e):d.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],i=0,o=t.getElementsByTagName(e);if("*"===e){while(n=o[i++])1===n.nodeType&&r.push(n);return r}return o},b.find.CLASS=d.getElementsByClassName&&function(e,t){if("undefined"!=typeof t.getElementsByClassName&&E)return t.getElementsByClassName(e)},s=[],v=[],(d.qsa=K.test(C.querySelectorAll))&&(ce(function(e){a.appendChild(e).innerHTML="<a id='"+k+"'></a><select id='"+k+"-\r\\' msallowcapture=''><option selected=''></option></select>",e.querySelectorAll("[msallowcapture^='']").length&&v.push("[*^$]="+M+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||v.push("\\["+M+"*(?:value|"+R+")"),e.querySelectorAll("[id~="+k+"-]").length||v.push("~="),e.querySelectorAll(":checked").length||v.push(":checked"),e.querySelectorAll("a#"+k+"+*").length||v.push(".#.+[+~]")}),ce(function(e){e.innerHTML="<a href='' disabled='disabled'></a><select disabled='disabled'><option/></select>";var t=C.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&v.push("name"+M+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&v.push(":enabled",":disabled"),a.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&v.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),v.push(",.*:")})),(d.matchesSelector=K.test(c=a.matches||a.webkitMatchesSelector||a.mozMatchesSelector||a.oMatchesSelector||a.msMatchesSelector))&&ce(function(e){d.disconnectedMatch=c.call(e,"*"),c.call(e,"[s!='']:x"),s.push("!=",$)}),v=v.length&&new RegExp(v.join("|")),s=s.length&&new RegExp(s.join("|")),t=K.test(a.compareDocumentPosition),y=t||K.test(a.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)while(t=t.parentNode)if(t===e)return!0;return!1},D=t?function(e,t){if(e===t)return l=!0,0;var n=!e.compareDocumentPosition-!t.compareDocumentPosition;return n||(1&(n=(e.ownerDocument||e)===(t.ownerDocument||t)?e.compareDocumentPosition(t):1)||!d.sortDetached&&t.compareDocumentPosition(e)===n?e===C||e.ownerDocument===m&&y(m,e)?-1:t===C||t.ownerDocument===m&&y(m,t)?1:u?P(u,e)-P(u,t):0:4&n?-1:1)}:function(e,t){if(e===t)return l=!0,0;var n,r=0,i=e.parentNode,o=t.parentNode,a=[e],s=[t];if(!i||!o)return e===C?-1:t===C?1:i?-1:o?1:u?P(u,e)-P(u,t):0;if(i===o)return pe(e,t);n=e;while(n=n.parentNode)a.unshift(n);n=t;while(n=n.parentNode)s.unshift(n);while(a[r]===s[r])r++;return r?pe(a[r],s[r]):a[r]===m?-1:s[r]===m?1:0}),C},se.matches=function(e,t){return se(e,null,null,t)},se.matchesSelector=function(e,t){if((e.ownerDocument||e)!==C&&T(e),d.matchesSelector&&E&&!A[t+" "]&&(!s||!s.test(t))&&(!v||!v.test(t)))try{var n=c.call(e,t);if(n||d.disconnectedMatch||e.document&&11!==e.document.nodeType)return n}catch(e){A(t,!0)}return 0<se(t,C,null,[e]).length},se.contains=function(e,t){return(e.ownerDocument||e)!==C&&T(e),y(e,t)},se.attr=function(e,t){(e.ownerDocument||e)!==C&&T(e);var n=b.attrHandle[t.toLowerCase()],r=n&&j.call(b.attrHandle,t.toLowerCase())?n(e,t,!E):void 0;return void 0!==r?r:d.attributes||!E?e.getAttribute(t):(r=e.getAttributeNode(t))&&r.specified?r.value:null},se.escape=function(e){return(e+"").replace(re,ie)},se.error=function(e){throw new Error("Syntax error, unrecognized expression: "+e)},se.uniqueSort=function(e){var t,n=[],r=0,i=0;if(l=!d.detectDuplicates,u=!d.sortStable&&e.slice(0),e.sort(D),l){while(t=e[i++])t===e[i]&&(r=n.push(i));while(r--)e.splice(n[r],1)}return u=null,e},o=se.getText=function(e){var t,n="",r=0,i=e.nodeType;if(i){if(1===i||9===i||11===i){if("string"==typeof e.textContent)return e.textContent;for(e=e.firstChild;e;e=e.nextSibling)n+=o(e)}else if(3===i||4===i)return e.nodeValue}else while(t=e[r++])n+=o(t);return n},(b=se.selectors={cacheLength:50,createPseudo:le,match:G,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(te,ne),e[3]=(e[3]||e[4]||e[5]||"").replace(te,ne),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||se.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&se.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return G.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&X.test(n)&&(t=h(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(te,ne).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=p[e+" "];return t||(t=new RegExp("(^|"+M+")"+e+"("+M+"|$)"))&&p(e,function(e){return t.test("string"==typeof e.className&&e.className||"undefined"!=typeof e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(n,r,i){return function(e){var t=se.attr(e,n);return null==t?"!="===r:!r||(t+="","="===r?t===i:"!="===r?t!==i:"^="===r?i&&0===t.indexOf(i):"*="===r?i&&-1<t.indexOf(i):"$="===r?i&&t.slice(-i.length)===i:"~="===r?-1<(" "+t.replace(F," ")+" ").indexOf(i):"|="===r&&(t===i||t.slice(0,i.length+1)===i+"-"))}},CHILD:function(h,e,t,g,v){var y="nth"!==h.slice(0,3),m="last"!==h.slice(-4),x="of-type"===e;return 1===g&&0===v?function(e){return!!e.parentNode}:function(e,t,n){var r,i,o,a,s,u,l=y!==m?"nextSibling":"previousSibling",c=e.parentNode,f=x&&e.nodeName.toLowerCase(),p=!n&&!x,d=!1;if(c){if(y){while(l){a=e;while(a=a[l])if(x?a.nodeName.toLowerCase()===f:1===a.nodeType)return!1;u=l="only"===h&&!u&&"nextSibling"}return!0}if(u=[m?c.firstChild:c.lastChild],m&&p){d=(s=(r=(i=(o=(a=c)[k]||(a[k]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]||[])[0]===S&&r[1])&&r[2],a=s&&c.childNodes[s];while(a=++s&&a&&a[l]||(d=s=0)||u.pop())if(1===a.nodeType&&++d&&a===e){i[h]=[S,s,d];break}}else if(p&&(d=s=(r=(i=(o=(a=e)[k]||(a[k]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]||[])[0]===S&&r[1]),!1===d)while(a=++s&&a&&a[l]||(d=s=0)||u.pop())if((x?a.nodeName.toLowerCase()===f:1===a.nodeType)&&++d&&(p&&((i=(o=a[k]||(a[k]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]=[S,d]),a===e))break;return(d-=v)===g||d%g==0&&0<=d/g}}},PSEUDO:function(e,o){var t,a=b.pseudos[e]||b.setFilters[e.toLowerCase()]||se.error("unsupported pseudo: "+e);return a[k]?a(o):1<a.length?(t=[e,e,"",o],b.setFilters.hasOwnProperty(e.toLowerCase())?le(function(e,t){var n,r=a(e,o),i=r.length;while(i--)e[n=P(e,r[i])]=!(t[n]=r[i])}):function(e){return a(e,0,t)}):a}},pseudos:{not:le(function(e){var r=[],i=[],s=f(e.replace(B,"$1"));return s[k]?le(function(e,t,n,r){var i,o=s(e,null,r,[]),a=e.length;while(a--)(i=o[a])&&(e[a]=!(t[a]=i))}):function(e,t,n){return r[0]=e,s(r,null,n,i),r[0]=null,!i.pop()}}),has:le(function(t){return function(e){return 0<se(t,e).length}}),contains:le(function(t){return t=t.replace(te,ne),function(e){return-1<(e.textContent||o(e)).indexOf(t)}}),lang:le(function(n){return V.test(n||"")||se.error("unsupported lang: "+n),n=n.replace(te,ne).toLowerCase(),function(e){var t;do{if(t=E?e.lang:e.getAttribute("xml:lang")||e.getAttribute("lang"))return(t=t.toLowerCase())===n||0===t.indexOf(n+"-")}while((e=e.parentNode)&&1===e.nodeType);return!1}}),target:function(e){var t=n.location&&n.location.hash;return t&&t.slice(1)===e.id},root:function(e){return e===a},focus:function(e){return e===C.activeElement&&(!C.hasFocus||C.hasFocus())&&!!(e.type||e.href||~e.tabIndex)},enabled:ge(!1),disabled:ge(!0),checked:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&!!e.checked||"option"===t&&!!e.selected},selected:function(e){return e.parentNode&&e.parentNode.selectedIndex,!0===e.selected},empty:function(e){for(e=e.firstChild;e;e=e.nextSibling)if(e.nodeType<6)return!1;return!0},parent:function(e){return!b.pseudos.empty(e)},header:function(e){return J.test(e.nodeName)},input:function(e){return Q.test(e.nodeName)},button:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&"button"===e.type||"button"===t},text:function(e){var t;return"input"===e.nodeName.toLowerCase()&&"text"===e.type&&(null==(t=e.getAttribute("type"))||"text"===t.toLowerCase())},first:ve(function(){return[0]}),last:ve(function(e,t){return[t-1]}),eq:ve(function(e,t,n){return[n<0?n+t:n]}),even:ve(function(e,t){for(var n=0;n<t;n+=2)e.push(n);return e}),odd:ve(function(e,t){for(var n=1;n<t;n+=2)e.push(n);return e}),lt:ve(function(e,t,n){for(var r=n<0?n+t:t<n?t:n;0<=--r;)e.push(r);return e}),gt:ve(function(e,t,n){for(var r=n<0?n+t:n;++r<t;)e.push(r);return e})}}).pseudos.nth=b.pseudos.eq,{radio:!0,checkbox:!0,file:!0,password:!0,image:!0})b.pseudos[e]=de(e);for(e in{submit:!0,reset:!0})b.pseudos[e]=he(e);function me(){}function xe(e){for(var t=0,n=e.length,r="";t<n;t++)r+=e[t].value;return r}function be(s,e,t){var u=e.dir,l=e.next,c=l||u,f=t&&"parentNode"===c,p=r++;return e.first?function(e,t,n){while(e=e[u])if(1===e.nodeType||f)return s(e,t,n);return!1}:function(e,t,n){var r,i,o,a=[S,p];if(n){while(e=e[u])if((1===e.nodeType||f)&&s(e,t,n))return!0}else while(e=e[u])if(1===e.nodeType||f)if(i=(o=e[k]||(e[k]={}))[e.uniqueID]||(o[e.uniqueID]={}),l&&l===e.nodeName.toLowerCase())e=e[u]||e;else{if((r=i[c])&&r[0]===S&&r[1]===p)return a[2]=r[2];if((i[c]=a)[2]=s(e,t,n))return!0}return!1}}function we(i){return 1<i.length?function(e,t,n){var r=i.length;while(r--)if(!i[r](e,t,n))return!1;return!0}:i[0]}function Te(e,t,n,r,i){for(var o,a=[],s=0,u=e.length,l=null!=t;s<u;s++)(o=e[s])&&(n&&!n(o,r,i)||(a.push(o),l&&t.push(s)));return a}function Ce(d,h,g,v,y,e){return v&&!v[k]&&(v=Ce(v)),y&&!y[k]&&(y=Ce(y,e)),le(function(e,t,n,r){var i,o,a,s=[],u=[],l=t.length,c=e||function(e,t,n){for(var r=0,i=t.length;r<i;r++)se(e,t[r],n);return n}(h||"*",n.nodeType?[n]:n,[]),f=!d||!e&&h?c:Te(c,s,d,n,r),p=g?y||(e?d:l||v)?[]:t:f;if(g&&g(f,p,n,r),v){i=Te(p,u),v(i,[],n,r),o=i.length;while(o--)(a=i[o])&&(p[u[o]]=!(f[u[o]]=a))}if(e){if(y||d){if(y){i=[],o=p.length;while(o--)(a=p[o])&&i.push(f[o]=a);y(null,p=[],i,r)}o=p.length;while(o--)(a=p[o])&&-1<(i=y?P(e,a):s[o])&&(e[i]=!(t[i]=a))}}else p=Te(p===t?p.splice(l,p.length):p),y?y(null,t,p,r):H.apply(t,p)})}function Ee(e){for(var i,t,n,r=e.length,o=b.relative[e[0].type],a=o||b.relative[" "],s=o?1:0,u=be(function(e){return e===i},a,!0),l=be(function(e){return-1<P(i,e)},a,!0),c=[function(e,t,n){var r=!o&&(n||t!==w)||((i=t).nodeType?u(e,t,n):l(e,t,n));return i=null,r}];s<r;s++)if(t=b.relative[e[s].type])c=[be(we(c),t)];else{if((t=b.filter[e[s].type].apply(null,e[s].matches))[k]){for(n=++s;n<r;n++)if(b.relative[e[n].type])break;return Ce(1<s&&we(c),1<s&&xe(e.slice(0,s-1).concat({value:" "===e[s-2].type?"*":""})).replace(B,"$1"),t,s<n&&Ee(e.slice(s,n)),n<r&&Ee(e=e.slice(n)),n<r&&xe(e))}c.push(t)}return we(c)}return me.prototype=b.filters=b.pseudos,b.setFilters=new me,h=se.tokenize=function(e,t){var n,r,i,o,a,s,u,l=x[e+" "];if(l)return t?0:l.slice(0);a=e,s=[],u=b.preFilter;while(a){for(o in n&&!(r=_.exec(a))||(r&&(a=a.slice(r[0].length)||a),s.push(i=[])),n=!1,(r=z.exec(a))&&(n=r.shift(),i.push({value:n,type:r[0].replace(B," ")}),a=a.slice(n.length)),b.filter)!(r=G[o].exec(a))||u[o]&&!(r=u[o](r))||(n=r.shift(),i.push({value:n,type:o,matches:r}),a=a.slice(n.length));if(!n)break}return t?a.length:a?se.error(e):x(e,s).slice(0)},f=se.compile=function(e,t){var n,v,y,m,x,r,i=[],o=[],a=N[e+" "];if(!a){t||(t=h(e)),n=t.length;while(n--)(a=Ee(t[n]))[k]?i.push(a):o.push(a);(a=N(e,(v=o,m=0<(y=i).length,x=0<v.length,r=function(e,t,n,r,i){var o,a,s,u=0,l="0",c=e&&[],f=[],p=w,d=e||x&&b.find.TAG("*",i),h=S+=null==p?1:Math.random()||.1,g=d.length;for(i&&(w=t===C||t||i);l!==g&&null!=(o=d[l]);l++){if(x&&o){a=0,t||o.ownerDocument===C||(T(o),n=!E);while(s=v[a++])if(s(o,t||C,n)){r.push(o);break}i&&(S=h)}m&&((o=!s&&o)&&u--,e&&c.push(o))}if(u+=l,m&&l!==u){a=0;while(s=y[a++])s(c,f,t,n);if(e){if(0<u)while(l--)c[l]||f[l]||(f[l]=q.call(r));f=Te(f)}H.apply(r,f),i&&!e&&0<f.length&&1<u+y.length&&se.uniqueSort(r)}return i&&(S=h,w=p),c},m?le(r):r))).selector=e}return a},g=se.select=function(e,t,n,r){var i,o,a,s,u,l="function"==typeof e&&e,c=!r&&h(e=l.selector||e);if(n=n||[],1===c.length){if(2<(o=c[0]=c[0].slice(0)).length&&"ID"===(a=o[0]).type&&9===t.nodeType&&E&&b.relative[o[1].type]){if(!(t=(b.find.ID(a.matches[0].replace(te,ne),t)||[])[0]))return n;l&&(t=t.parentNode),e=e.slice(o.shift().value.length)}i=G.needsContext.test(e)?0:o.length;while(i--){if(a=o[i],b.relative[s=a.type])break;if((u=b.find[s])&&(r=u(a.matches[0].replace(te,ne),ee.test(o[0].type)&&ye(t.parentNode)||t))){if(o.splice(i,1),!(e=r.length&&xe(o)))return H.apply(n,r),n;break}}}return(l||f(e,c))(r,t,!E,n,!t||ee.test(e)&&ye(t.parentNode)||t),n},d.sortStable=k.split("").sort(D).join("")===k,d.detectDuplicates=!!l,T(),d.sortDetached=ce(function(e){return 1&e.compareDocumentPosition(C.createElement("fieldset"))}),ce(function(e){return e.innerHTML="<a href='#'></a>","#"===e.firstChild.getAttribute("href")})||fe("type|href|height|width",function(e,t,n){if(!n)return e.getAttribute(t,"type"===t.toLowerCase()?1:2)}),d.attributes&&ce(function(e){return e.innerHTML="<input/>",e.firstChild.setAttribute("value",""),""===e.firstChild.getAttribute("value")})||fe("value",function(e,t,n){if(!n&&"input"===e.nodeName.toLowerCase())return e.defaultValue}),ce(function(e){return null==e.getAttribute("disabled")})||fe(R,function(e,t,n){var r;if(!n)return!0===e[t]?t.toLowerCase():(r=e.getAttributeNode(t))&&r.specified?r.value:null}),se}(C);k.find=h,k.expr=h.selectors,k.expr[":"]=k.expr.pseudos,k.uniqueSort=k.unique=h.uniqueSort,k.text=h.getText,k.isXMLDoc=h.isXML,k.contains=h.contains,k.escapeSelector=h.escape;var T=function(e,t,n){var r=[],i=void 0!==n;while((e=e[t])&&9!==e.nodeType)if(1===e.nodeType){if(i&&k(e).is(n))break;r.push(e)}return r},S=function(e,t){for(var n=[];e;e=e.nextSibling)1===e.nodeType&&e!==t&&n.push(e);return n},N=k.expr.match.needsContext;function A(e,t){return e.nodeName&&e.nodeName.toLowerCase()===t.toLowerCase()}var D=/^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function j(e,n,r){return m(n)?k.grep(e,function(e,t){return!!n.call(e,t,e)!==r}):n.nodeType?k.grep(e,function(e){return e===n!==r}):"string"!=typeof n?k.grep(e,function(e){return-1<i.call(n,e)!==r}):k.filter(n,e,r)}k.filter=function(e,t,n){var r=t[0];return n&&(e=":not("+e+")"),1===t.length&&1===r.nodeType?k.find.matchesSelector(r,e)?[r]:[]:k.find.matches(e,k.grep(t,function(e){return 1===e.nodeType}))},k.fn.extend({find:function(e){var t,n,r=this.length,i=this;if("string"!=typeof e)return this.pushStack(k(e).filter(function(){for(t=0;t<r;t++)if(k.contains(i[t],this))return!0}));for(n=this.pushStack([]),t=0;t<r;t++)k.find(e,i[t],n);return 1<r?k.uniqueSort(n):n},filter:function(e){return this.pushStack(j(this,e||[],!1))},not:function(e){return this.pushStack(j(this,e||[],!0))},is:function(e){return!!j(this,"string"==typeof e&&N.test(e)?k(e):e||[],!1).length}});var q,L=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/;(k.fn.init=function(e,t,n){var r,i;if(!e)return this;if(n=n||q,"string"==typeof e){if(!(r="<"===e[0]&&">"===e[e.length-1]&&3<=e.length?[null,e,null]:L.exec(e))||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof k?t[0]:t,k.merge(this,k.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:E,!0)),D.test(r[1])&&k.isPlainObject(t))for(r in t)m(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return(i=E.getElementById(r[2]))&&(this[0]=i,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):m(e)?void 0!==n.ready?n.ready(e):e(k):k.makeArray(e,this)}).prototype=k.fn,q=k(E);var H=/^(?:parents|prev(?:Until|All))/,O={children:!0,contents:!0,next:!0,prev:!0};function P(e,t){while((e=e[t])&&1!==e.nodeType);return e}k.fn.extend({has:function(e){var t=k(e,this),n=t.length;return this.filter(function(){for(var e=0;e<n;e++)if(k.contains(this,t[e]))return!0})},closest:function(e,t){var n,r=0,i=this.length,o=[],a="string"!=typeof e&&k(e);if(!N.test(e))for(;r<i;r++)for(n=this[r];n&&n!==t;n=n.parentNode)if(n.nodeType<11&&(a?-1<a.index(n):1===n.nodeType&&k.find.matchesSelector(n,e))){o.push(n);break}return this.pushStack(1<o.length?k.uniqueSort(o):o)},index:function(e){return e?"string"==typeof e?i.call(k(e),this[0]):i.call(this,e.jquery?e[0]:e):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(e,t){return this.pushStack(k.uniqueSort(k.merge(this.get(),k(e,t))))},addBack:function(e){return this.add(null==e?this.prevObject:this.prevObject.filter(e))}}),k.each({parent:function(e){var t=e.parentNode;return t&&11!==t.nodeType?t:null},parents:function(e){return T(e,"parentNode")},parentsUntil:function(e,t,n){return T(e,"parentNode",n)},next:function(e){return P(e,"nextSibling")},prev:function(e){return P(e,"previousSibling")},nextAll:function(e){return T(e,"nextSibling")},prevAll:function(e){return T(e,"previousSibling")},nextUntil:function(e,t,n){return T(e,"nextSibling",n)},prevUntil:function(e,t,n){return T(e,"previousSibling",n)},siblings:function(e){return S((e.parentNode||{}).firstChild,e)},children:function(e){return S(e.firstChild)},contents:function(e){return"undefined"!=typeof e.contentDocument?e.contentDocument:(A(e,"template")&&(e=e.content||e),k.merge([],e.childNodes))}},function(r,i){k.fn[r]=function(e,t){var n=k.map(this,i,e);return"Until"!==r.slice(-5)&&(t=e),t&&"string"==typeof t&&(n=k.filter(t,n)),1<this.length&&(O[r]||k.uniqueSort(n),H.test(r)&&n.reverse()),this.pushStack(n)}});var R=/[^\x20\t\r\n\f]+/g;function M(e){return e}function I(e){throw e}function W(e,t,n,r){var i;try{e&&m(i=e.promise)?i.call(e).done(t).fail(n):e&&m(i=e.then)?i.call(e,t,n):t.apply(void 0,[e].slice(r))}catch(e){n.apply(void 0,[e])}}k.Callbacks=function(r){var e,n;r="string"==typeof r?(e=r,n={},k.each(e.match(R)||[],function(e,t){n[t]=!0}),n):k.extend({},r);var i,t,o,a,s=[],u=[],l=-1,c=function(){for(a=a||r.once,o=i=!0;u.length;l=-1){t=u.shift();while(++l<s.length)!1===s[l].apply(t[0],t[1])&&r.stopOnFalse&&(l=s.length,t=!1)}r.memory||(t=!1),i=!1,a&&(s=t?[]:"")},f={add:function(){return s&&(t&&!i&&(l=s.length-1,u.push(t)),function n(e){k.each(e,function(e,t){m(t)?r.unique&&f.has(t)||s.push(t):t&&t.length&&"string"!==w(t)&&n(t)})}(arguments),t&&!i&&c()),this},remove:function(){return k.each(arguments,function(e,t){var n;while(-1<(n=k.inArray(t,s,n)))s.splice(n,1),n<=l&&l--}),this},has:function(e){return e?-1<k.inArray(e,s):0<s.length},empty:function(){return s&&(s=[]),this},disable:function(){return a=u=[],s=t="",this},disabled:function(){return!s},lock:function(){return a=u=[],t||i||(s=t=""),this},locked:function(){return!!a},fireWith:function(e,t){return a||(t=[e,(t=t||[]).slice?t.slice():t],u.push(t),i||c()),this},fire:function(){return f.fireWith(this,arguments),this},fired:function(){return!!o}};return f},k.extend({Deferred:function(e){var o=[["notify","progress",k.Callbacks("memory"),k.Callbacks("memory"),2],["resolve","done",k.Callbacks("once memory"),k.Callbacks("once memory"),0,"resolved"],["reject","fail",k.Callbacks("once memory"),k.Callbacks("once memory"),1,"rejected"]],i="pending",a={state:function(){return i},always:function(){return s.done(arguments).fail(arguments),this},"catch":function(e){return a.then(null,e)},pipe:function(){var i=arguments;return k.Deferred(function(r){k.each(o,function(e,t){var n=m(i[t[4]])&&i[t[4]];s[t[1]](function(){var e=n&&n.apply(this,arguments);e&&m(e.promise)?e.promise().progress(r.notify).done(r.resolve).fail(r.reject):r[t[0]+"With"](this,n?[e]:arguments)})}),i=null}).promise()},then:function(t,n,r){var u=0;function l(i,o,a,s){return function(){var n=this,r=arguments,e=function(){var e,t;if(!(i<u)){if((e=a.apply(n,r))===o.promise())throw new TypeError("Thenable self-resolution");t=e&&("object"==typeof e||"function"==typeof e)&&e.then,m(t)?s?t.call(e,l(u,o,M,s),l(u,o,I,s)):(u++,t.call(e,l(u,o,M,s),l(u,o,I,s),l(u,o,M,o.notifyWith))):(a!==M&&(n=void 0,r=[e]),(s||o.resolveWith)(n,r))}},t=s?e:function(){try{e()}catch(e){k.Deferred.exceptionHook&&k.Deferred.exceptionHook(e,t.stackTrace),u<=i+1&&(a!==I&&(n=void 0,r=[e]),o.rejectWith(n,r))}};i?t():(k.Deferred.getStackHook&&(t.stackTrace=k.Deferred.getStackHook()),C.setTimeout(t))}}return k.Deferred(function(e){o[0][3].add(l(0,e,m(r)?r:M,e.notifyWith)),o[1][3].add(l(0,e,m(t)?t:M)),o[2][3].add(l(0,e,m(n)?n:I))}).promise()},promise:function(e){return null!=e?k.extend(e,a):a}},s={};return k.each(o,function(e,t){var n=t[2],r=t[5];a[t[1]]=n.add,r&&n.add(function(){i=r},o[3-e][2].disable,o[3-e][3].disable,o[0][2].lock,o[0][3].lock),n.add(t[3].fire),s[t[0]]=function(){return s[t[0]+"With"](this===s?void 0:this,arguments),this},s[t[0]+"With"]=n.fireWith}),a.promise(s),e&&e.call(s,s),s},when:function(e){var n=arguments.length,t=n,r=Array(t),i=s.call(arguments),o=k.Deferred(),a=function(t){return function(e){r[t]=this,i[t]=1<arguments.length?s.call(arguments):e,--n||o.resolveWith(r,i)}};if(n<=1&&(W(e,o.done(a(t)).resolve,o.reject,!n),"pending"===o.state()||m(i[t]&&i[t].then)))return o.then();while(t--)W(i[t],a(t),o.reject);return o.promise()}});var $=/^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;k.Deferred.exceptionHook=function(e,t){C.console&&C.console.warn&&e&&$.test(e.name)&&C.console.warn("jQuery.Deferred exception: "+e.message,e.stack,t)},k.readyException=function(e){C.setTimeout(function(){throw e})};var F=k.Deferred();function B(){E.removeEventListener("DOMContentLoaded",B),C.removeEventListener("load",B),k.ready()}k.fn.ready=function(e){return F.then(e)["catch"](function(e){k.readyException(e)}),this},k.extend({isReady:!1,readyWait:1,ready:function(e){(!0===e?--k.readyWait:k.isReady)||(k.isReady=!0)!==e&&0<--k.readyWait||F.resolveWith(E,[k])}}),k.ready.then=F.then,"complete"===E.readyState||"loading"!==E.readyState&&!E.documentElement.doScroll?C.setTimeout(k.ready):(E.addEventListener("DOMContentLoaded",B),C.addEventListener("load",B));var _=function(e,t,n,r,i,o,a){var s=0,u=e.length,l=null==n;if("object"===w(n))for(s in i=!0,n)_(e,t,s,n[s],!0,o,a);else if(void 0!==r&&(i=!0,m(r)||(a=!0),l&&(a?(t.call(e,r),t=null):(l=t,t=function(e,t,n){return l.call(k(e),n)})),t))for(;s<u;s++)t(e[s],n,a?r:r.call(e[s],s,t(e[s],n)));return i?e:l?t.call(e):u?t(e[0],n):o},z=/^-ms-/,U=/-([a-z])/g;function X(e,t){return t.toUpperCase()}function V(e){return e.replace(z,"ms-").replace(U,X)}var G=function(e){return 1===e.nodeType||9===e.nodeType||!+e.nodeType};function Y(){this.expando=k.expando+Y.uid++}Y.uid=1,Y.prototype={cache:function(e){var t=e[this.expando];return t||(t={},G(e)&&(e.nodeType?e[this.expando]=t:Object.defineProperty(e,this.expando,{value:t,configurable:!0}))),t},set:function(e,t,n){var r,i=this.cache(e);if("string"==typeof t)i[V(t)]=n;else for(r in t)i[V(r)]=t[r];return i},get:function(e,t){return void 0===t?this.cache(e):e[this.expando]&&e[this.expando][V(t)]},access:function(e,t,n){return void 0===t||t&&"string"==typeof t&&void 0===n?this.get(e,t):(this.set(e,t,n),void 0!==n?n:t)},remove:function(e,t){var n,r=e[this.expando];if(void 0!==r){if(void 0!==t){n=(t=Array.isArray(t)?t.map(V):(t=V(t))in r?[t]:t.match(R)||[]).length;while(n--)delete r[t[n]]}(void 0===t||k.isEmptyObject(r))&&(e.nodeType?e[this.expando]=void 0:delete e[this.expando])}},hasData:function(e){var t=e[this.expando];return void 0!==t&&!k.isEmptyObject(t)}};var Q=new Y,J=new Y,K=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,Z=/[A-Z]/g;function ee(e,t,n){var r,i;if(void 0===n&&1===e.nodeType)if(r="data-"+t.replace(Z,"-$&").toLowerCase(),"string"==typeof(n=e.getAttribute(r))){try{n="true"===(i=n)||"false"!==i&&("null"===i?null:i===+i+""?+i:K.test(i)?JSON.parse(i):i)}catch(e){}J.set(e,t,n)}else n=void 0;return n}k.extend({hasData:function(e){return J.hasData(e)||Q.hasData(e)},data:function(e,t,n){return J.access(e,t,n)},removeData:function(e,t){J.remove(e,t)},_data:function(e,t,n){return Q.access(e,t,n)},_removeData:function(e,t){Q.remove(e,t)}}),k.fn.extend({data:function(n,e){var t,r,i,o=this[0],a=o&&o.attributes;if(void 0===n){if(this.length&&(i=J.get(o),1===o.nodeType&&!Q.get(o,"hasDataAttrs"))){t=a.length;while(t--)a[t]&&0===(r=a[t].name).indexOf("data-")&&(r=V(r.slice(5)),ee(o,r,i[r]));Q.set(o,"hasDataAttrs",!0)}return i}return"object"==typeof n?this.each(function(){J.set(this,n)}):_(this,function(e){var t;if(o&&void 0===e)return void 0!==(t=J.get(o,n))?t:void 0!==(t=ee(o,n))?t:void 0;this.each(function(){J.set(this,n,e)})},null,e,1<arguments.length,null,!0)},removeData:function(e){return this.each(function(){J.remove(this,e)})}}),k.extend({queue:function(e,t,n){var r;if(e)return t=(t||"fx")+"queue",r=Q.get(e,t),n&&(!r||Array.isArray(n)?r=Q.access(e,t,k.makeArray(n)):r.push(n)),r||[]},dequeue:function(e,t){t=t||"fx";var n=k.queue(e,t),r=n.length,i=n.shift(),o=k._queueHooks(e,t);"inprogress"===i&&(i=n.shift(),r--),i&&("fx"===t&&n.unshift("inprogress"),delete o.stop,i.call(e,function(){k.dequeue(e,t)},o)),!r&&o&&o.empty.fire()},_queueHooks:function(e,t){var n=t+"queueHooks";return Q.get(e,n)||Q.access(e,n,{empty:k.Callbacks("once memory").add(function(){Q.remove(e,[t+"queue",n])})})}}),k.fn.extend({queue:function(t,n){var e=2;return"string"!=typeof t&&(n=t,t="fx",e--),arguments.length<e?k.queue(this[0],t):void 0===n?this:this.each(function(){var e=k.queue(this,t,n);k._queueHooks(this,t),"fx"===t&&"inprogress"!==e[0]&&k.dequeue(this,t)})},dequeue:function(e){return this.each(function(){k.dequeue(this,e)})},clearQueue:function(e){return this.queue(e||"fx",[])},promise:function(e,t){var n,r=1,i=k.Deferred(),o=this,a=this.length,s=function(){--r||i.resolveWith(o,[o])};"string"!=typeof e&&(t=e,e=void 0),e=e||"fx";while(a--)(n=Q.get(o[a],e+"queueHooks"))&&n.empty&&(r++,n.empty.add(s));return s(),i.promise(t)}});var te=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,ne=new RegExp("^(?:([+-])=|)("+te+")([a-z%]*)$","i"),re=["Top","Right","Bottom","Left"],ie=E.documentElement,oe=function(e){return k.contains(e.ownerDocument,e)},ae={composed:!0};ie.getRootNode&&(oe=function(e){return k.contains(e.ownerDocument,e)||e.getRootNode(ae)===e.ownerDocument});var se=function(e,t){return"none"===(e=t||e).style.display||""===e.style.display&&oe(e)&&"none"===k.css(e,"display")},ue=function(e,t,n,r){var i,o,a={};for(o in t)a[o]=e.style[o],e.style[o]=t[o];for(o in i=n.apply(e,r||[]),t)e.style[o]=a[o];return i};function le(e,t,n,r){var i,o,a=20,s=r?function(){return r.cur()}:function(){return k.css(e,t,"")},u=s(),l=n&&n[3]||(k.cssNumber[t]?"":"px"),c=e.nodeType&&(k.cssNumber[t]||"px"!==l&&+u)&&ne.exec(k.css(e,t));if(c&&c[3]!==l){u/=2,l=l||c[3],c=+u||1;while(a--)k.style(e,t,c+l),(1-o)*(1-(o=s()/u||.5))<=0&&(a=0),c/=o;c*=2,k.style(e,t,c+l),n=n||[]}return n&&(c=+c||+u||0,i=n[1]?c+(n[1]+1)*n[2]:+n[2],r&&(r.unit=l,r.start=c,r.end=i)),i}var ce={};function fe(e,t){for(var n,r,i,o,a,s,u,l=[],c=0,f=e.length;c<f;c++)(r=e[c]).style&&(n=r.style.display,t?("none"===n&&(l[c]=Q.get(r,"display")||null,l[c]||(r.style.display="")),""===r.style.display&&se(r)&&(l[c]=(u=a=o=void 0,a=(i=r).ownerDocument,s=i.nodeName,(u=ce[s])||(o=a.body.appendChild(a.createElement(s)),u=k.css(o,"display"),o.parentNode.removeChild(o),"none"===u&&(u="block"),ce[s]=u)))):"none"!==n&&(l[c]="none",Q.set(r,"display",n)));for(c=0;c<f;c++)null!=l[c]&&(e[c].style.display=l[c]);return e}k.fn.extend({show:function(){return fe(this,!0)},hide:function(){return fe(this)},toggle:function(e){return"boolean"==typeof e?e?this.show():this.hide():this.each(function(){se(this)?k(this).show():k(this).hide()})}});var pe=/^(?:checkbox|radio)$/i,de=/<([a-z][^\/\0>\x20\t\r\n\f]*)/i,he=/^$|^module$|\/(?:java|ecma)script/i,ge={option:[1,"<select multiple='multiple'>","</select>"],thead:[1,"<table>","</table>"],col:[2,"<table><colgroup>","</colgroup></table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],_default:[0,"",""]};function ve(e,t){var n;return n="undefined"!=typeof e.getElementsByTagName?e.getElementsByTagName(t||"*"):"undefined"!=typeof e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&A(e,t)?k.merge([e],n):n}function ye(e,t){for(var n=0,r=e.length;n<r;n++)Q.set(e[n],"globalEval",!t||Q.get(t[n],"globalEval"))}ge.optgroup=ge.option,ge.tbody=ge.tfoot=ge.colgroup=ge.caption=ge.thead,ge.th=ge.td;var me,xe,be=/<|&#?\w+;/;function we(e,t,n,r,i){for(var o,a,s,u,l,c,f=t.createDocumentFragment(),p=[],d=0,h=e.length;d<h;d++)if((o=e[d])||0===o)if("object"===w(o))k.merge(p,o.nodeType?[o]:o);else if(be.test(o)){a=a||f.appendChild(t.createElement("div")),s=(de.exec(o)||["",""])[1].toLowerCase(),u=ge[s]||ge._default,a.innerHTML=u[1]+k.htmlPrefilter(o)+u[2],c=u[0];while(c--)a=a.lastChild;k.merge(p,a.childNodes),(a=f.firstChild).textContent=""}else p.push(t.createTextNode(o));f.textContent="",d=0;while(o=p[d++])if(r&&-1<k.inArray(o,r))i&&i.push(o);else if(l=oe(o),a=ve(f.appendChild(o),"script"),l&&ye(a),n){c=0;while(o=a[c++])he.test(o.type||"")&&n.push(o)}return f}me=E.createDocumentFragment().appendChild(E.createElement("div")),(xe=E.createElement("input")).setAttribute("type","radio"),xe.setAttribute("checked","checked"),xe.setAttribute("name","t"),me.appendChild(xe),y.checkClone=me.cloneNode(!0).cloneNode(!0).lastChild.checked,me.innerHTML="<textarea>x</textarea>",y.noCloneChecked=!!me.cloneNode(!0).lastChild.defaultValue;var Te=/^key/,Ce=/^(?:mouse|pointer|contextmenu|drag|drop)|click/,Ee=/^([^.]*)(?:\.(.+)|)/;function ke(){return!0}function Se(){return!1}function Ne(e,t){return e===function(){try{return E.activeElement}catch(e){}}()==("focus"===t)}function Ae(e,t,n,r,i,o){var a,s;if("object"==typeof t){for(s in"string"!=typeof n&&(r=r||n,n=void 0),t)Ae(e,s,n,r,t[s],o);return e}if(null==r&&null==i?(i=n,r=n=void 0):null==i&&("string"==typeof n?(i=r,r=void 0):(i=r,r=n,n=void 0)),!1===i)i=Se;else if(!i)return e;return 1===o&&(a=i,(i=function(e){return k().off(e),a.apply(this,arguments)}).guid=a.guid||(a.guid=k.guid++)),e.each(function(){k.event.add(this,t,i,r,n)})}function De(e,i,o){o?(Q.set(e,i,!1),k.event.add(e,i,{namespace:!1,handler:function(e){var t,n,r=Q.get(this,i);if(1&e.isTrigger&&this[i]){if(r.length)(k.event.special[i]||{}).delegateType&&e.stopPropagation();else if(r=s.call(arguments),Q.set(this,i,r),t=o(this,i),this[i](),r!==(n=Q.get(this,i))||t?Q.set(this,i,!1):n={},r!==n)return e.stopImmediatePropagation(),e.preventDefault(),n.value}else r.length&&(Q.set(this,i,{value:k.event.trigger(k.extend(r[0],k.Event.prototype),r.slice(1),this)}),e.stopImmediatePropagation())}})):void 0===Q.get(e,i)&&k.event.add(e,i,ke)}k.event={global:{},add:function(t,e,n,r,i){var o,a,s,u,l,c,f,p,d,h,g,v=Q.get(t);if(v){n.handler&&(n=(o=n).handler,i=o.selector),i&&k.find.matchesSelector(ie,i),n.guid||(n.guid=k.guid++),(u=v.events)||(u=v.events={}),(a=v.handle)||(a=v.handle=function(e){return"undefined"!=typeof k&&k.event.triggered!==e.type?k.event.dispatch.apply(t,arguments):void 0}),l=(e=(e||"").match(R)||[""]).length;while(l--)d=g=(s=Ee.exec(e[l])||[])[1],h=(s[2]||"").split(".").sort(),d&&(f=k.event.special[d]||{},d=(i?f.delegateType:f.bindType)||d,f=k.event.special[d]||{},c=k.extend({type:d,origType:g,data:r,handler:n,guid:n.guid,selector:i,needsContext:i&&k.expr.match.needsContext.test(i),namespace:h.join(".")},o),(p=u[d])||((p=u[d]=[]).delegateCount=0,f.setup&&!1!==f.setup.call(t,r,h,a)||t.addEventListener&&t.addEventListener(d,a)),f.add&&(f.add.call(t,c),c.handler.guid||(c.handler.guid=n.guid)),i?p.splice(p.delegateCount++,0,c):p.push(c),k.event.global[d]=!0)}},remove:function(e,t,n,r,i){var o,a,s,u,l,c,f,p,d,h,g,v=Q.hasData(e)&&Q.get(e);if(v&&(u=v.events)){l=(t=(t||"").match(R)||[""]).length;while(l--)if(d=g=(s=Ee.exec(t[l])||[])[1],h=(s[2]||"").split(".").sort(),d){f=k.event.special[d]||{},p=u[d=(r?f.delegateType:f.bindType)||d]||[],s=s[2]&&new RegExp("(^|\\.)"+h.join("\\.(?:.*\\.|)")+"(\\.|$)"),a=o=p.length;while(o--)c=p[o],!i&&g!==c.origType||n&&n.guid!==c.guid||s&&!s.test(c.namespace)||r&&r!==c.selector&&("**"!==r||!c.selector)||(p.splice(o,1),c.selector&&p.delegateCount--,f.remove&&f.remove.call(e,c));a&&!p.length&&(f.teardown&&!1!==f.teardown.call(e,h,v.handle)||k.removeEvent(e,d,v.handle),delete u[d])}else for(d in u)k.event.remove(e,d+t[l],n,r,!0);k.isEmptyObject(u)&&Q.remove(e,"handle events")}},dispatch:function(e){var t,n,r,i,o,a,s=k.event.fix(e),u=new Array(arguments.length),l=(Q.get(this,"events")||{})[s.type]||[],c=k.event.special[s.type]||{};for(u[0]=s,t=1;t<arguments.length;t++)u[t]=arguments[t];if(s.delegateTarget=this,!c.preDispatch||!1!==c.preDispatch.call(this,s)){a=k.event.handlers.call(this,s,l),t=0;while((i=a[t++])&&!s.isPropagationStopped()){s.currentTarget=i.elem,n=0;while((o=i.handlers[n++])&&!s.isImmediatePropagationStopped())s.rnamespace&&!1!==o.namespace&&!s.rnamespace.test(o.namespace)||(s.handleObj=o,s.data=o.data,void 0!==(r=((k.event.special[o.origType]||{}).handle||o.handler).apply(i.elem,u))&&!1===(s.result=r)&&(s.preventDefault(),s.stopPropagation()))}return c.postDispatch&&c.postDispatch.call(this,s),s.result}},handlers:function(e,t){var n,r,i,o,a,s=[],u=t.delegateCount,l=e.target;if(u&&l.nodeType&&!("click"===e.type&&1<=e.button))for(;l!==this;l=l.parentNode||this)if(1===l.nodeType&&("click"!==e.type||!0!==l.disabled)){for(o=[],a={},n=0;n<u;n++)void 0===a[i=(r=t[n]).selector+" "]&&(a[i]=r.needsContext?-1<k(i,this).index(l):k.find(i,this,null,[l]).length),a[i]&&o.push(r);o.length&&s.push({elem:l,handlers:o})}return l=this,u<t.length&&s.push({elem:l,handlers:t.slice(u)}),s},addProp:function(t,e){Object.defineProperty(k.Event.prototype,t,{enumerable:!0,configurable:!0,get:m(e)?function(){if(this.originalEvent)return e(this.originalEvent)}:function(){if(this.originalEvent)return this.originalEvent[t]},set:function(e){Object.defineProperty(this,t,{enumerable:!0,configurable:!0,writable:!0,value:e})}})},fix:function(e){return e[k.expando]?e:new k.Event(e)},special:{load:{noBubble:!0},click:{setup:function(e){var t=this||e;return pe.test(t.type)&&t.click&&A(t,"input")&&De(t,"click",ke),!1},trigger:function(e){var t=this||e;return pe.test(t.type)&&t.click&&A(t,"input")&&De(t,"click"),!0},_default:function(e){var t=e.target;return pe.test(t.type)&&t.click&&A(t,"input")&&Q.get(t,"click")||A(t,"a")}},beforeunload:{postDispatch:function(e){void 0!==e.result&&e.originalEvent&&(e.originalEvent.returnValue=e.result)}}}},k.removeEvent=function(e,t,n){e.removeEventListener&&e.removeEventListener(t,n)},k.Event=function(e,t){if(!(this instanceof k.Event))return new k.Event(e,t);e&&e.type?(this.originalEvent=e,this.type=e.type,this.isDefaultPrevented=e.defaultPrevented||void 0===e.defaultPrevented&&!1===e.returnValue?ke:Se,this.target=e.target&&3===e.target.nodeType?e.target.parentNode:e.target,this.currentTarget=e.currentTarget,this.relatedTarget=e.relatedTarget):this.type=e,t&&k.extend(this,t),this.timeStamp=e&&e.timeStamp||Date.now(),this[k.expando]=!0},k.Event.prototype={constructor:k.Event,isDefaultPrevented:Se,isPropagationStopped:Se,isImmediatePropagationStopped:Se,isSimulated:!1,preventDefault:function(){var e=this.originalEvent;this.isDefaultPrevented=ke,e&&!this.isSimulated&&e.preventDefault()},stopPropagation:function(){var e=this.originalEvent;this.isPropagationStopped=ke,e&&!this.isSimulated&&e.stopPropagation()},stopImmediatePropagation:function(){var e=this.originalEvent;this.isImmediatePropagationStopped=ke,e&&!this.isSimulated&&e.stopImmediatePropagation(),this.stopPropagation()}},k.each({altKey:!0,bubbles:!0,cancelable:!0,changedTouches:!0,ctrlKey:!0,detail:!0,eventPhase:!0,metaKey:!0,pageX:!0,pageY:!0,shiftKey:!0,view:!0,"char":!0,code:!0,charCode:!0,key:!0,keyCode:!0,button:!0,buttons:!0,clientX:!0,clientY:!0,offsetX:!0,offsetY:!0,pointerId:!0,pointerType:!0,screenX:!0,screenY:!0,targetTouches:!0,toElement:!0,touches:!0,which:function(e){var t=e.button;return null==e.which&&Te.test(e.type)?null!=e.charCode?e.charCode:e.keyCode:!e.which&&void 0!==t&&Ce.test(e.type)?1&t?1:2&t?3:4&t?2:0:e.which}},k.event.addProp),k.each({focus:"focusin",blur:"focusout"},function(e,t){k.event.special[e]={setup:function(){return De(this,e,Ne),!1},trigger:function(){return De(this,e),!0},delegateType:t}}),k.each({mouseenter:"mouseover",mouseleave:"mouseout",pointerenter:"pointerover",pointerleave:"pointerout"},function(e,i){k.event.special[e]={delegateType:i,bindType:i,handle:function(e){var t,n=e.relatedTarget,r=e.handleObj;return n&&(n===this||k.contains(this,n))||(e.type=r.origType,t=r.handler.apply(this,arguments),e.type=i),t}}}),k.fn.extend({on:function(e,t,n,r){return Ae(this,e,t,n,r)},one:function(e,t,n,r){return Ae(this,e,t,n,r,1)},off:function(e,t,n){var r,i;if(e&&e.preventDefault&&e.handleObj)return r=e.handleObj,k(e.delegateTarget).off(r.namespace?r.origType+"."+r.namespace:r.origType,r.selector,r.handler),this;if("object"==typeof e){for(i in e)this.off(i,t,e[i]);return this}return!1!==t&&"function"!=typeof t||(n=t,t=void 0),!1===n&&(n=Se),this.each(function(){k.event.remove(this,e,n,t)})}});var je=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi,qe=/<script|<style|<link/i,Le=/checked\s*(?:[^=]|=\s*.checked.)/i,He=/^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;function Oe(e,t){return A(e,"table")&&A(11!==t.nodeType?t:t.firstChild,"tr")&&k(e).children("tbody")[0]||e}function Pe(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function Re(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function Me(e,t){var n,r,i,o,a,s,u,l;if(1===t.nodeType){if(Q.hasData(e)&&(o=Q.access(e),a=Q.set(t,o),l=o.events))for(i in delete a.handle,a.events={},l)for(n=0,r=l[i].length;n<r;n++)k.event.add(t,i,l[i][n]);J.hasData(e)&&(s=J.access(e),u=k.extend({},s),J.set(t,u))}}function Ie(n,r,i,o){r=g.apply([],r);var e,t,a,s,u,l,c=0,f=n.length,p=f-1,d=r[0],h=m(d);if(h||1<f&&"string"==typeof d&&!y.checkClone&&Le.test(d))return n.each(function(e){var t=n.eq(e);h&&(r[0]=d.call(this,e,t.html())),Ie(t,r,i,o)});if(f&&(t=(e=we(r,n[0].ownerDocument,!1,n,o)).firstChild,1===e.childNodes.length&&(e=t),t||o)){for(s=(a=k.map(ve(e,"script"),Pe)).length;c<f;c++)u=e,c!==p&&(u=k.clone(u,!0,!0),s&&k.merge(a,ve(u,"script"))),i.call(n[c],u,c);if(s)for(l=a[a.length-1].ownerDocument,k.map(a,Re),c=0;c<s;c++)u=a[c],he.test(u.type||"")&&!Q.access(u,"globalEval")&&k.contains(l,u)&&(u.src&&"module"!==(u.type||"").toLowerCase()?k._evalUrl&&!u.noModule&&k._evalUrl(u.src,{nonce:u.nonce||u.getAttribute("nonce")}):b(u.textContent.replace(He,""),u,l))}return n}function We(e,t,n){for(var r,i=t?k.filter(t,e):e,o=0;null!=(r=i[o]);o++)n||1!==r.nodeType||k.cleanData(ve(r)),r.parentNode&&(n&&oe(r)&&ye(ve(r,"script")),r.parentNode.removeChild(r));return e}k.extend({htmlPrefilter:function(e){return e.replace(je,"<$1></$2>")},clone:function(e,t,n){var r,i,o,a,s,u,l,c=e.cloneNode(!0),f=oe(e);if(!(y.noCloneChecked||1!==e.nodeType&&11!==e.nodeType||k.isXMLDoc(e)))for(a=ve(c),r=0,i=(o=ve(e)).length;r<i;r++)s=o[r],u=a[r],void 0,"input"===(l=u.nodeName.toLowerCase())&&pe.test(s.type)?u.checked=s.checked:"input"!==l&&"textarea"!==l||(u.defaultValue=s.defaultValue);if(t)if(n)for(o=o||ve(e),a=a||ve(c),r=0,i=o.length;r<i;r++)Me(o[r],a[r]);else Me(e,c);return 0<(a=ve(c,"script")).length&&ye(a,!f&&ve(e,"script")),c},cleanData:function(e){for(var t,n,r,i=k.event.special,o=0;void 0!==(n=e[o]);o++)if(G(n)){if(t=n[Q.expando]){if(t.events)for(r in t.events)i[r]?k.event.remove(n,r):k.removeEvent(n,r,t.handle);n[Q.expando]=void 0}n[J.expando]&&(n[J.expando]=void 0)}}}),k.fn.extend({detach:function(e){return We(this,e,!0)},remove:function(e){return We(this,e)},text:function(e){return _(this,function(e){return void 0===e?k.text(this):this.empty().each(function(){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||(this.textContent=e)})},null,e,arguments.length)},append:function(){return Ie(this,arguments,function(e){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||Oe(this,e).appendChild(e)})},prepend:function(){return Ie(this,arguments,function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=Oe(this,e);t.insertBefore(e,t.firstChild)}})},before:function(){return Ie(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this)})},after:function(){return Ie(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this.nextSibling)})},empty:function(){for(var e,t=0;null!=(e=this[t]);t++)1===e.nodeType&&(k.cleanData(ve(e,!1)),e.textContent="");return this},clone:function(e,t){return e=null!=e&&e,t=null==t?e:t,this.map(function(){return k.clone(this,e,t)})},html:function(e){return _(this,function(e){var t=this[0]||{},n=0,r=this.length;if(void 0===e&&1===t.nodeType)return t.innerHTML;if("string"==typeof e&&!qe.test(e)&&!ge[(de.exec(e)||["",""])[1].toLowerCase()]){e=k.htmlPrefilter(e);try{for(;n<r;n++)1===(t=this[n]||{}).nodeType&&(k.cleanData(ve(t,!1)),t.innerHTML=e);t=0}catch(e){}}t&&this.empty().append(e)},null,e,arguments.length)},replaceWith:function(){var n=[];return Ie(this,arguments,function(e){var t=this.parentNode;k.inArray(this,n)<0&&(k.cleanData(ve(this)),t&&t.replaceChild(e,this))},n)}}),k.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(e,a){k.fn[e]=function(e){for(var t,n=[],r=k(e),i=r.length-1,o=0;o<=i;o++)t=o===i?this:this.clone(!0),k(r[o])[a](t),u.apply(n,t.get());return this.pushStack(n)}});var $e=new RegExp("^("+te+")(?!px)[a-z%]+$","i"),Fe=function(e){var t=e.ownerDocument.defaultView;return t&&t.opener||(t=C),t.getComputedStyle(e)},Be=new RegExp(re.join("|"),"i");function _e(e,t,n){var r,i,o,a,s=e.style;return(n=n||Fe(e))&&(""!==(a=n.getPropertyValue(t)||n[t])||oe(e)||(a=k.style(e,t)),!y.pixelBoxStyles()&&$e.test(a)&&Be.test(t)&&(r=s.width,i=s.minWidth,o=s.maxWidth,s.minWidth=s.maxWidth=s.width=a,a=n.width,s.width=r,s.minWidth=i,s.maxWidth=o)),void 0!==a?a+"":a}function ze(e,t){return{get:function(){if(!e())return(this.get=t).apply(this,arguments);delete this.get}}}!function(){function e(){if(u){s.style.cssText="position:absolute;left:-11111px;width:60px;margin-top:1px;padding:0;border:0",u.style.cssText="position:relative;display:block;box-sizing:border-box;overflow:scroll;margin:auto;border:1px;padding:1px;width:60%;top:1%",ie.appendChild(s).appendChild(u);var e=C.getComputedStyle(u);n="1%"!==e.top,a=12===t(e.marginLeft),u.style.right="60%",o=36===t(e.right),r=36===t(e.width),u.style.position="absolute",i=12===t(u.offsetWidth/3),ie.removeChild(s),u=null}}function t(e){return Math.round(parseFloat(e))}var n,r,i,o,a,s=E.createElement("div"),u=E.createElement("div");u.style&&(u.style.backgroundClip="content-box",u.cloneNode(!0).style.backgroundClip="",y.clearCloneStyle="content-box"===u.style.backgroundClip,k.extend(y,{boxSizingReliable:function(){return e(),r},pixelBoxStyles:function(){return e(),o},pixelPosition:function(){return e(),n},reliableMarginLeft:function(){return e(),a},scrollboxSize:function(){return e(),i}}))}();var Ue=["Webkit","Moz","ms"],Xe=E.createElement("div").style,Ve={};function Ge(e){var t=k.cssProps[e]||Ve[e];return t||(e in Xe?e:Ve[e]=function(e){var t=e[0].toUpperCase()+e.slice(1),n=Ue.length;while(n--)if((e=Ue[n]+t)in Xe)return e}(e)||e)}var Ye=/^(none|table(?!-c[ea]).+)/,Qe=/^--/,Je={position:"absolute",visibility:"hidden",display:"block"},Ke={letterSpacing:"0",fontWeight:"400"};function Ze(e,t,n){var r=ne.exec(t);return r?Math.max(0,r[2]-(n||0))+(r[3]||"px"):t}function et(e,t,n,r,i,o){var a="width"===t?1:0,s=0,u=0;if(n===(r?"border":"content"))return 0;for(;a<4;a+=2)"margin"===n&&(u+=k.css(e,n+re[a],!0,i)),r?("content"===n&&(u-=k.css(e,"padding"+re[a],!0,i)),"margin"!==n&&(u-=k.css(e,"border"+re[a]+"Width",!0,i))):(u+=k.css(e,"padding"+re[a],!0,i),"padding"!==n?u+=k.css(e,"border"+re[a]+"Width",!0,i):s+=k.css(e,"border"+re[a]+"Width",!0,i));return!r&&0<=o&&(u+=Math.max(0,Math.ceil(e["offset"+t[0].toUpperCase()+t.slice(1)]-o-u-s-.5))||0),u}function tt(e,t,n){var r=Fe(e),i=(!y.boxSizingReliable()||n)&&"border-box"===k.css(e,"boxSizing",!1,r),o=i,a=_e(e,t,r),s="offset"+t[0].toUpperCase()+t.slice(1);if($e.test(a)){if(!n)return a;a="auto"}return(!y.boxSizingReliable()&&i||"auto"===a||!parseFloat(a)&&"inline"===k.css(e,"display",!1,r))&&e.getClientRects().length&&(i="border-box"===k.css(e,"boxSizing",!1,r),(o=s in e)&&(a=e[s])),(a=parseFloat(a)||0)+et(e,t,n||(i?"border":"content"),o,r,a)+"px"}function nt(e,t,n,r,i){return new nt.prototype.init(e,t,n,r,i)}k.extend({cssHooks:{opacity:{get:function(e,t){if(t){var n=_e(e,"opacity");return""===n?"1":n}}}},cssNumber:{animationIterationCount:!0,columnCount:!0,fillOpacity:!0,flexGrow:!0,flexShrink:!0,fontWeight:!0,gridArea:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnStart:!0,gridRow:!0,gridRowEnd:!0,gridRowStart:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{},style:function(e,t,n,r){if(e&&3!==e.nodeType&&8!==e.nodeType&&e.style){var i,o,a,s=V(t),u=Qe.test(t),l=e.style;if(u||(t=Ge(s)),a=k.cssHooks[t]||k.cssHooks[s],void 0===n)return a&&"get"in a&&void 0!==(i=a.get(e,!1,r))?i:l[t];"string"===(o=typeof n)&&(i=ne.exec(n))&&i[1]&&(n=le(e,t,i),o="number"),null!=n&&n==n&&("number"!==o||u||(n+=i&&i[3]||(k.cssNumber[s]?"":"px")),y.clearCloneStyle||""!==n||0!==t.indexOf("background")||(l[t]="inherit"),a&&"set"in a&&void 0===(n=a.set(e,n,r))||(u?l.setProperty(t,n):l[t]=n))}},css:function(e,t,n,r){var i,o,a,s=V(t);return Qe.test(t)||(t=Ge(s)),(a=k.cssHooks[t]||k.cssHooks[s])&&"get"in a&&(i=a.get(e,!0,n)),void 0===i&&(i=_e(e,t,r)),"normal"===i&&t in Ke&&(i=Ke[t]),""===n||n?(o=parseFloat(i),!0===n||isFinite(o)?o||0:i):i}}),k.each(["height","width"],function(e,u){k.cssHooks[u]={get:function(e,t,n){if(t)return!Ye.test(k.css(e,"display"))||e.getClientRects().length&&e.getBoundingClientRect().width?tt(e,u,n):ue(e,Je,function(){return tt(e,u,n)})},set:function(e,t,n){var r,i=Fe(e),o=!y.scrollboxSize()&&"absolute"===i.position,a=(o||n)&&"border-box"===k.css(e,"boxSizing",!1,i),s=n?et(e,u,n,a,i):0;return a&&o&&(s-=Math.ceil(e["offset"+u[0].toUpperCase()+u.slice(1)]-parseFloat(i[u])-et(e,u,"border",!1,i)-.5)),s&&(r=ne.exec(t))&&"px"!==(r[3]||"px")&&(e.style[u]=t,t=k.css(e,u)),Ze(0,t,s)}}}),k.cssHooks.marginLeft=ze(y.reliableMarginLeft,function(e,t){if(t)return(parseFloat(_e(e,"marginLeft"))||e.getBoundingClientRect().left-ue(e,{marginLeft:0},function(){return e.getBoundingClientRect().left}))+"px"}),k.each({margin:"",padding:"",border:"Width"},function(i,o){k.cssHooks[i+o]={expand:function(e){for(var t=0,n={},r="string"==typeof e?e.split(" "):[e];t<4;t++)n[i+re[t]+o]=r[t]||r[t-2]||r[0];return n}},"margin"!==i&&(k.cssHooks[i+o].set=Ze)}),k.fn.extend({css:function(e,t){return _(this,function(e,t,n){var r,i,o={},a=0;if(Array.isArray(t)){for(r=Fe(e),i=t.length;a<i;a++)o[t[a]]=k.css(e,t[a],!1,r);return o}return void 0!==n?k.style(e,t,n):k.css(e,t)},e,t,1<arguments.length)}}),((k.Tween=nt).prototype={constructor:nt,init:function(e,t,n,r,i,o){this.elem=e,this.prop=n,this.easing=i||k.easing._default,this.options=t,this.start=this.now=this.cur(),this.end=r,this.unit=o||(k.cssNumber[n]?"":"px")},cur:function(){var e=nt.propHooks[this.prop];return e&&e.get?e.get(this):nt.propHooks._default.get(this)},run:function(e){var t,n=nt.propHooks[this.prop];return this.options.duration?this.pos=t=k.easing[this.easing](e,this.options.duration*e,0,1,this.options.duration):this.pos=t=e,this.now=(this.end-this.start)*t+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),n&&n.set?n.set(this):nt.propHooks._default.set(this),this}}).init.prototype=nt.prototype,(nt.propHooks={_default:{get:function(e){var t;return 1!==e.elem.nodeType||null!=e.elem[e.prop]&&null==e.elem.style[e.prop]?e.elem[e.prop]:(t=k.css(e.elem,e.prop,""))&&"auto"!==t?t:0},set:function(e){k.fx.step[e.prop]?k.fx.step[e.prop](e):1!==e.elem.nodeType||!k.cssHooks[e.prop]&&null==e.elem.style[Ge(e.prop)]?e.elem[e.prop]=e.now:k.style(e.elem,e.prop,e.now+e.unit)}}}).scrollTop=nt.propHooks.scrollLeft={set:function(e){e.elem.nodeType&&e.elem.parentNode&&(e.elem[e.prop]=e.now)}},k.easing={linear:function(e){return e},swing:function(e){return.5-Math.cos(e*Math.PI)/2},_default:"swing"},k.fx=nt.prototype.init,k.fx.step={};var rt,it,ot,at,st=/^(?:toggle|show|hide)$/,ut=/queueHooks$/;function lt(){it&&(!1===E.hidden&&C.requestAnimationFrame?C.requestAnimationFrame(lt):C.setTimeout(lt,k.fx.interval),k.fx.tick())}function ct(){return C.setTimeout(function(){rt=void 0}),rt=Date.now()}function ft(e,t){var n,r=0,i={height:e};for(t=t?1:0;r<4;r+=2-t)i["margin"+(n=re[r])]=i["padding"+n]=e;return t&&(i.opacity=i.width=e),i}function pt(e,t,n){for(var r,i=(dt.tweeners[t]||[]).concat(dt.tweeners["*"]),o=0,a=i.length;o<a;o++)if(r=i[o].call(n,t,e))return r}function dt(o,e,t){var n,a,r=0,i=dt.prefilters.length,s=k.Deferred().always(function(){delete u.elem}),u=function(){if(a)return!1;for(var e=rt||ct(),t=Math.max(0,l.startTime+l.duration-e),n=1-(t/l.duration||0),r=0,i=l.tweens.length;r<i;r++)l.tweens[r].run(n);return s.notifyWith(o,[l,n,t]),n<1&&i?t:(i||s.notifyWith(o,[l,1,0]),s.resolveWith(o,[l]),!1)},l=s.promise({elem:o,props:k.extend({},e),opts:k.extend(!0,{specialEasing:{},easing:k.easing._default},t),originalProperties:e,originalOptions:t,startTime:rt||ct(),duration:t.duration,tweens:[],createTween:function(e,t){var n=k.Tween(o,l.opts,e,t,l.opts.specialEasing[e]||l.opts.easing);return l.tweens.push(n),n},stop:function(e){var t=0,n=e?l.tweens.length:0;if(a)return this;for(a=!0;t<n;t++)l.tweens[t].run(1);return e?(s.notifyWith(o,[l,1,0]),s.resolveWith(o,[l,e])):s.rejectWith(o,[l,e]),this}}),c=l.props;for(!function(e,t){var n,r,i,o,a;for(n in e)if(i=t[r=V(n)],o=e[n],Array.isArray(o)&&(i=o[1],o=e[n]=o[0]),n!==r&&(e[r]=o,delete e[n]),(a=k.cssHooks[r])&&"expand"in a)for(n in o=a.expand(o),delete e[r],o)n in e||(e[n]=o[n],t[n]=i);else t[r]=i}(c,l.opts.specialEasing);r<i;r++)if(n=dt.prefilters[r].call(l,o,c,l.opts))return m(n.stop)&&(k._queueHooks(l.elem,l.opts.queue).stop=n.stop.bind(n)),n;return k.map(c,pt,l),m(l.opts.start)&&l.opts.start.call(o,l),l.progress(l.opts.progress).done(l.opts.done,l.opts.complete).fail(l.opts.fail).always(l.opts.always),k.fx.timer(k.extend(u,{elem:o,anim:l,queue:l.opts.queue})),l}k.Animation=k.extend(dt,{tweeners:{"*":[function(e,t){var n=this.createTween(e,t);return le(n.elem,e,ne.exec(t),n),n}]},tweener:function(e,t){m(e)?(t=e,e=["*"]):e=e.match(R);for(var n,r=0,i=e.length;r<i;r++)n=e[r],dt.tweeners[n]=dt.tweeners[n]||[],dt.tweeners[n].unshift(t)},prefilters:[function(e,t,n){var r,i,o,a,s,u,l,c,f="width"in t||"height"in t,p=this,d={},h=e.style,g=e.nodeType&&se(e),v=Q.get(e,"fxshow");for(r in n.queue||(null==(a=k._queueHooks(e,"fx")).unqueued&&(a.unqueued=0,s=a.empty.fire,a.empty.fire=function(){a.unqueued||s()}),a.unqueued++,p.always(function(){p.always(function(){a.unqueued--,k.queue(e,"fx").length||a.empty.fire()})})),t)if(i=t[r],st.test(i)){if(delete t[r],o=o||"toggle"===i,i===(g?"hide":"show")){if("show"!==i||!v||void 0===v[r])continue;g=!0}d[r]=v&&v[r]||k.style(e,r)}if((u=!k.isEmptyObject(t))||!k.isEmptyObject(d))for(r in f&&1===e.nodeType&&(n.overflow=[h.overflow,h.overflowX,h.overflowY],null==(l=v&&v.display)&&(l=Q.get(e,"display")),"none"===(c=k.css(e,"display"))&&(l?c=l:(fe([e],!0),l=e.style.display||l,c=k.css(e,"display"),fe([e]))),("inline"===c||"inline-block"===c&&null!=l)&&"none"===k.css(e,"float")&&(u||(p.done(function(){h.display=l}),null==l&&(c=h.display,l="none"===c?"":c)),h.display="inline-block")),n.overflow&&(h.overflow="hidden",p.always(function(){h.overflow=n.overflow[0],h.overflowX=n.overflow[1],h.overflowY=n.overflow[2]})),u=!1,d)u||(v?"hidden"in v&&(g=v.hidden):v=Q.access(e,"fxshow",{display:l}),o&&(v.hidden=!g),g&&fe([e],!0),p.done(function(){for(r in g||fe([e]),Q.remove(e,"fxshow"),d)k.style(e,r,d[r])})),u=pt(g?v[r]:0,r,p),r in v||(v[r]=u.start,g&&(u.end=u.start,u.start=0))}],prefilter:function(e,t){t?dt.prefilters.unshift(e):dt.prefilters.push(e)}}),k.speed=function(e,t,n){var r=e&&"object"==typeof e?k.extend({},e):{complete:n||!n&&t||m(e)&&e,duration:e,easing:n&&t||t&&!m(t)&&t};return k.fx.off?r.duration=0:"number"!=typeof r.duration&&(r.duration in k.fx.speeds?r.duration=k.fx.speeds[r.duration]:r.duration=k.fx.speeds._default),null!=r.queue&&!0!==r.queue||(r.queue="fx"),r.old=r.complete,r.complete=function(){m(r.old)&&r.old.call(this),r.queue&&k.dequeue(this,r.queue)},r},k.fn.extend({fadeTo:function(e,t,n,r){return this.filter(se).css("opacity",0).show().end().animate({opacity:t},e,n,r)},animate:function(t,e,n,r){var i=k.isEmptyObject(t),o=k.speed(e,n,r),a=function(){var e=dt(this,k.extend({},t),o);(i||Q.get(this,"finish"))&&e.stop(!0)};return a.finish=a,i||!1===o.queue?this.each(a):this.queue(o.queue,a)},stop:function(i,e,o){var a=function(e){var t=e.stop;delete e.stop,t(o)};return"string"!=typeof i&&(o=e,e=i,i=void 0),e&&!1!==i&&this.queue(i||"fx",[]),this.each(function(){var e=!0,t=null!=i&&i+"queueHooks",n=k.timers,r=Q.get(this);if(t)r[t]&&r[t].stop&&a(r[t]);else for(t in r)r[t]&&r[t].stop&&ut.test(t)&&a(r[t]);for(t=n.length;t--;)n[t].elem!==this||null!=i&&n[t].queue!==i||(n[t].anim.stop(o),e=!1,n.splice(t,1));!e&&o||k.dequeue(this,i)})},finish:function(a){return!1!==a&&(a=a||"fx"),this.each(function(){var e,t=Q.get(this),n=t[a+"queue"],r=t[a+"queueHooks"],i=k.timers,o=n?n.length:0;for(t.finish=!0,k.queue(this,a,[]),r&&r.stop&&r.stop.call(this,!0),e=i.length;e--;)i[e].elem===this&&i[e].queue===a&&(i[e].anim.stop(!0),i.splice(e,1));for(e=0;e<o;e++)n[e]&&n[e].finish&&n[e].finish.call(this);delete t.finish})}}),k.each(["toggle","show","hide"],function(e,r){var i=k.fn[r];k.fn[r]=function(e,t,n){return null==e||"boolean"==typeof e?i.apply(this,arguments):this.animate(ft(r,!0),e,t,n)}}),k.each({slideDown:ft("show"),slideUp:ft("hide"),slideToggle:ft("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(e,r){k.fn[e]=function(e,t,n){return this.animate(r,e,t,n)}}),k.timers=[],k.fx.tick=function(){var e,t=0,n=k.timers;for(rt=Date.now();t<n.length;t++)(e=n[t])()||n[t]!==e||n.splice(t--,1);n.length||k.fx.stop(),rt=void 0},k.fx.timer=function(e){k.timers.push(e),k.fx.start()},k.fx.interval=13,k.fx.start=function(){it||(it=!0,lt())},k.fx.stop=function(){it=null},k.fx.speeds={slow:600,fast:200,_default:400},k.fn.delay=function(r,e){return r=k.fx&&k.fx.speeds[r]||r,e=e||"fx",this.queue(e,function(e,t){var n=C.setTimeout(e,r);t.stop=function(){C.clearTimeout(n)}})},ot=E.createElement("input"),at=E.createElement("select").appendChild(E.createElement("option")),ot.type="checkbox",y.checkOn=""!==ot.value,y.optSelected=at.selected,(ot=E.createElement("input")).value="t",ot.type="radio",y.radioValue="t"===ot.value;var ht,gt=k.expr.attrHandle;k.fn.extend({attr:function(e,t){return _(this,k.attr,e,t,1<arguments.length)},removeAttr:function(e){return this.each(function(){k.removeAttr(this,e)})}}),k.extend({attr:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return"undefined"==typeof e.getAttribute?k.prop(e,t,n):(1===o&&k.isXMLDoc(e)||(i=k.attrHooks[t.toLowerCase()]||(k.expr.match.bool.test(t)?ht:void 0)),void 0!==n?null===n?void k.removeAttr(e,t):i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:(e.setAttribute(t,n+""),n):i&&"get"in i&&null!==(r=i.get(e,t))?r:null==(r=k.find.attr(e,t))?void 0:r)},attrHooks:{type:{set:function(e,t){if(!y.radioValue&&"radio"===t&&A(e,"input")){var n=e.value;return e.setAttribute("type",t),n&&(e.value=n),t}}}},removeAttr:function(e,t){var n,r=0,i=t&&t.match(R);if(i&&1===e.nodeType)while(n=i[r++])e.removeAttribute(n)}}),ht={set:function(e,t,n){return!1===t?k.removeAttr(e,n):e.setAttribute(n,n),n}},k.each(k.expr.match.bool.source.match(/\w+/g),function(e,t){var a=gt[t]||k.find.attr;gt[t]=function(e,t,n){var r,i,o=t.toLowerCase();return n||(i=gt[o],gt[o]=r,r=null!=a(e,t,n)?o:null,gt[o]=i),r}});var vt=/^(?:input|select|textarea|button)$/i,yt=/^(?:a|area)$/i;function mt(e){return(e.match(R)||[]).join(" ")}function xt(e){return e.getAttribute&&e.getAttribute("class")||""}function bt(e){return Array.isArray(e)?e:"string"==typeof e&&e.match(R)||[]}k.fn.extend({prop:function(e,t){return _(this,k.prop,e,t,1<arguments.length)},removeProp:function(e){return this.each(function(){delete this[k.propFix[e]||e]})}}),k.extend({prop:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return 1===o&&k.isXMLDoc(e)||(t=k.propFix[t]||t,i=k.propHooks[t]),void 0!==n?i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:e[t]=n:i&&"get"in i&&null!==(r=i.get(e,t))?r:e[t]},propHooks:{tabIndex:{get:function(e){var t=k.find.attr(e,"tabindex");return t?parseInt(t,10):vt.test(e.nodeName)||yt.test(e.nodeName)&&e.href?0:-1}}},propFix:{"for":"htmlFor","class":"className"}}),y.optSelected||(k.propHooks.selected={get:function(e){var t=e.parentNode;return t&&t.parentNode&&t.parentNode.selectedIndex,null},set:function(e){var t=e.parentNode;t&&(t.selectedIndex,t.parentNode&&t.parentNode.selectedIndex)}}),k.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){k.propFix[this.toLowerCase()]=this}),k.fn.extend({addClass:function(t){var e,n,r,i,o,a,s,u=0;if(m(t))return this.each(function(e){k(this).addClass(t.call(this,e,xt(this)))});if((e=bt(t)).length)while(n=this[u++])if(i=xt(n),r=1===n.nodeType&&" "+mt(i)+" "){a=0;while(o=e[a++])r.indexOf(" "+o+" ")<0&&(r+=o+" ");i!==(s=mt(r))&&n.setAttribute("class",s)}return this},removeClass:function(t){var e,n,r,i,o,a,s,u=0;if(m(t))return this.each(function(e){k(this).removeClass(t.call(this,e,xt(this)))});if(!arguments.length)return this.attr("class","");if((e=bt(t)).length)while(n=this[u++])if(i=xt(n),r=1===n.nodeType&&" "+mt(i)+" "){a=0;while(o=e[a++])while(-1<r.indexOf(" "+o+" "))r=r.replace(" "+o+" "," ");i!==(s=mt(r))&&n.setAttribute("class",s)}return this},toggleClass:function(i,t){var o=typeof i,a="string"===o||Array.isArray(i);return"boolean"==typeof t&&a?t?this.addClass(i):this.removeClass(i):m(i)?this.each(function(e){k(this).toggleClass(i.call(this,e,xt(this),t),t)}):this.each(function(){var e,t,n,r;if(a){t=0,n=k(this),r=bt(i);while(e=r[t++])n.hasClass(e)?n.removeClass(e):n.addClass(e)}else void 0!==i&&"boolean"!==o||((e=xt(this))&&Q.set(this,"__className__",e),this.setAttribute&&this.setAttribute("class",e||!1===i?"":Q.get(this,"__className__")||""))})},hasClass:function(e){var t,n,r=0;t=" "+e+" ";while(n=this[r++])if(1===n.nodeType&&-1<(" "+mt(xt(n))+" ").indexOf(t))return!0;return!1}});var wt=/\r/g;k.fn.extend({val:function(n){var r,e,i,t=this[0];return arguments.length?(i=m(n),this.each(function(e){var t;1===this.nodeType&&(null==(t=i?n.call(this,e,k(this).val()):n)?t="":"number"==typeof t?t+="":Array.isArray(t)&&(t=k.map(t,function(e){return null==e?"":e+""})),(r=k.valHooks[this.type]||k.valHooks[this.nodeName.toLowerCase()])&&"set"in r&&void 0!==r.set(this,t,"value")||(this.value=t))})):t?(r=k.valHooks[t.type]||k.valHooks[t.nodeName.toLowerCase()])&&"get"in r&&void 0!==(e=r.get(t,"value"))?e:"string"==typeof(e=t.value)?e.replace(wt,""):null==e?"":e:void 0}}),k.extend({valHooks:{option:{get:function(e){var t=k.find.attr(e,"value");return null!=t?t:mt(k.text(e))}},select:{get:function(e){var t,n,r,i=e.options,o=e.selectedIndex,a="select-one"===e.type,s=a?null:[],u=a?o+1:i.length;for(r=o<0?u:a?o:0;r<u;r++)if(((n=i[r]).selected||r===o)&&!n.disabled&&(!n.parentNode.disabled||!A(n.parentNode,"optgroup"))){if(t=k(n).val(),a)return t;s.push(t)}return s},set:function(e,t){var n,r,i=e.options,o=k.makeArray(t),a=i.length;while(a--)((r=i[a]).selected=-1<k.inArray(k.valHooks.option.get(r),o))&&(n=!0);return n||(e.selectedIndex=-1),o}}}}),k.each(["radio","checkbox"],function(){k.valHooks[this]={set:function(e,t){if(Array.isArray(t))return e.checked=-1<k.inArray(k(e).val(),t)}},y.checkOn||(k.valHooks[this].get=function(e){return null===e.getAttribute("value")?"on":e.value})}),y.focusin="onfocusin"in C;var Tt=/^(?:focusinfocus|focusoutblur)$/,Ct=function(e){e.stopPropagation()};k.extend(k.event,{trigger:function(e,t,n,r){var i,o,a,s,u,l,c,f,p=[n||E],d=v.call(e,"type")?e.type:e,h=v.call(e,"namespace")?e.namespace.split("."):[];if(o=f=a=n=n||E,3!==n.nodeType&&8!==n.nodeType&&!Tt.test(d+k.event.triggered)&&(-1<d.indexOf(".")&&(d=(h=d.split(".")).shift(),h.sort()),u=d.indexOf(":")<0&&"on"+d,(e=e[k.expando]?e:new k.Event(d,"object"==typeof e&&e)).isTrigger=r?2:3,e.namespace=h.join("."),e.rnamespace=e.namespace?new RegExp("(^|\\.)"+h.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,e.result=void 0,e.target||(e.target=n),t=null==t?[e]:k.makeArray(t,[e]),c=k.event.special[d]||{},r||!c.trigger||!1!==c.trigger.apply(n,t))){if(!r&&!c.noBubble&&!x(n)){for(s=c.delegateType||d,Tt.test(s+d)||(o=o.parentNode);o;o=o.parentNode)p.push(o),a=o;a===(n.ownerDocument||E)&&p.push(a.defaultView||a.parentWindow||C)}i=0;while((o=p[i++])&&!e.isPropagationStopped())f=o,e.type=1<i?s:c.bindType||d,(l=(Q.get(o,"events")||{})[e.type]&&Q.get(o,"handle"))&&l.apply(o,t),(l=u&&o[u])&&l.apply&&G(o)&&(e.result=l.apply(o,t),!1===e.result&&e.preventDefault());return e.type=d,r||e.isDefaultPrevented()||c._default&&!1!==c._default.apply(p.pop(),t)||!G(n)||u&&m(n[d])&&!x(n)&&((a=n[u])&&(n[u]=null),k.event.triggered=d,e.isPropagationStopped()&&f.addEventListener(d,Ct),n[d](),e.isPropagationStopped()&&f.removeEventListener(d,Ct),k.event.triggered=void 0,a&&(n[u]=a)),e.result}},simulate:function(e,t,n){var r=k.extend(new k.Event,n,{type:e,isSimulated:!0});k.event.trigger(r,null,t)}}),k.fn.extend({trigger:function(e,t){return this.each(function(){k.event.trigger(e,t,this)})},triggerHandler:function(e,t){var n=this[0];if(n)return k.event.trigger(e,t,n,!0)}}),y.focusin||k.each({focus:"focusin",blur:"focusout"},function(n,r){var i=function(e){k.event.simulate(r,e.target,k.event.fix(e))};k.event.special[r]={setup:function(){var e=this.ownerDocument||this,t=Q.access(e,r);t||e.addEventListener(n,i,!0),Q.access(e,r,(t||0)+1)},teardown:function(){var e=this.ownerDocument||this,t=Q.access(e,r)-1;t?Q.access(e,r,t):(e.removeEventListener(n,i,!0),Q.remove(e,r))}}});var Et=C.location,kt=Date.now(),St=/\?/;k.parseXML=function(e){var t;if(!e||"string"!=typeof e)return null;try{t=(new C.DOMParser).parseFromString(e,"text/xml")}catch(e){t=void 0}return t&&!t.getElementsByTagName("parsererror").length||k.error("Invalid XML: "+e),t};var Nt=/\[\]$/,At=/\r?\n/g,Dt=/^(?:submit|button|image|reset|file)$/i,jt=/^(?:input|select|textarea|keygen)/i;function qt(n,e,r,i){var t;if(Array.isArray(e))k.each(e,function(e,t){r||Nt.test(n)?i(n,t):qt(n+"["+("object"==typeof t&&null!=t?e:"")+"]",t,r,i)});else if(r||"object"!==w(e))i(n,e);else for(t in e)qt(n+"["+t+"]",e[t],r,i)}k.param=function(e,t){var n,r=[],i=function(e,t){var n=m(t)?t():t;r[r.length]=encodeURIComponent(e)+"="+encodeURIComponent(null==n?"":n)};if(null==e)return"";if(Array.isArray(e)||e.jquery&&!k.isPlainObject(e))k.each(e,function(){i(this.name,this.value)});else for(n in e)qt(n,e[n],t,i);return r.join("&")},k.fn.extend({serialize:function(){return k.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var e=k.prop(this,"elements");return e?k.makeArray(e):this}).filter(function(){var e=this.type;return this.name&&!k(this).is(":disabled")&&jt.test(this.nodeName)&&!Dt.test(e)&&(this.checked||!pe.test(e))}).map(function(e,t){var n=k(this).val();return null==n?null:Array.isArray(n)?k.map(n,function(e){return{name:t.name,value:e.replace(At,"\r\n")}}):{name:t.name,value:n.replace(At,"\r\n")}}).get()}});var Lt=/%20/g,Ht=/#.*$/,Ot=/([?&])_=[^&]*/,Pt=/^(.*?):[ \t]*([^\r\n]*)$/gm,Rt=/^(?:GET|HEAD)$/,Mt=/^\/\//,It={},Wt={},$t="*/".concat("*"),Ft=E.createElement("a");function Bt(o){return function(e,t){"string"!=typeof e&&(t=e,e="*");var n,r=0,i=e.toLowerCase().match(R)||[];if(m(t))while(n=i[r++])"+"===n[0]?(n=n.slice(1)||"*",(o[n]=o[n]||[]).unshift(t)):(o[n]=o[n]||[]).push(t)}}function _t(t,i,o,a){var s={},u=t===Wt;function l(e){var r;return s[e]=!0,k.each(t[e]||[],function(e,t){var n=t(i,o,a);return"string"!=typeof n||u||s[n]?u?!(r=n):void 0:(i.dataTypes.unshift(n),l(n),!1)}),r}return l(i.dataTypes[0])||!s["*"]&&l("*")}function zt(e,t){var n,r,i=k.ajaxSettings.flatOptions||{};for(n in t)void 0!==t[n]&&((i[n]?e:r||(r={}))[n]=t[n]);return r&&k.extend(!0,e,r),e}Ft.href=Et.href,k.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:Et.href,type:"GET",isLocal:/^(?:about|app|app-storage|.+-extension|file|res|widget):$/.test(Et.protocol),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":$t,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/\bxml\b/,html:/\bhtml/,json:/\bjson\b/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":JSON.parse,"text xml":k.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(e,t){return t?zt(zt(e,k.ajaxSettings),t):zt(k.ajaxSettings,e)},ajaxPrefilter:Bt(It),ajaxTransport:Bt(Wt),ajax:function(e,t){"object"==typeof e&&(t=e,e=void 0),t=t||{};var c,f,p,n,d,r,h,g,i,o,v=k.ajaxSetup({},t),y=v.context||v,m=v.context&&(y.nodeType||y.jquery)?k(y):k.event,x=k.Deferred(),b=k.Callbacks("once memory"),w=v.statusCode||{},a={},s={},u="canceled",T={readyState:0,getResponseHeader:function(e){var t;if(h){if(!n){n={};while(t=Pt.exec(p))n[t[1].toLowerCase()+" "]=(n[t[1].toLowerCase()+" "]||[]).concat(t[2])}t=n[e.toLowerCase()+" "]}return null==t?null:t.join(", ")},getAllResponseHeaders:function(){return h?p:null},setRequestHeader:function(e,t){return null==h&&(e=s[e.toLowerCase()]=s[e.toLowerCase()]||e,a[e]=t),this},overrideMimeType:function(e){return null==h&&(v.mimeType=e),this},statusCode:function(e){var t;if(e)if(h)T.always(e[T.status]);else for(t in e)w[t]=[w[t],e[t]];return this},abort:function(e){var t=e||u;return c&&c.abort(t),l(0,t),this}};if(x.promise(T),v.url=((e||v.url||Et.href)+"").replace(Mt,Et.protocol+"//"),v.type=t.method||t.type||v.method||v.type,v.dataTypes=(v.dataType||"*").toLowerCase().match(R)||[""],null==v.crossDomain){r=E.createElement("a");try{r.href=v.url,r.href=r.href,v.crossDomain=Ft.protocol+"//"+Ft.host!=r.protocol+"//"+r.host}catch(e){v.crossDomain=!0}}if(v.data&&v.processData&&"string"!=typeof v.data&&(v.data=k.param(v.data,v.traditional)),_t(It,v,t,T),h)return T;for(i in(g=k.event&&v.global)&&0==k.active++&&k.event.trigger("ajaxStart"),v.type=v.type.toUpperCase(),v.hasContent=!Rt.test(v.type),f=v.url.replace(Ht,""),v.hasContent?v.data&&v.processData&&0===(v.contentType||"").indexOf("application/x-www-form-urlencoded")&&(v.data=v.data.replace(Lt,"+")):(o=v.url.slice(f.length),v.data&&(v.processData||"string"==typeof v.data)&&(f+=(St.test(f)?"&":"?")+v.data,delete v.data),!1===v.cache&&(f=f.replace(Ot,"$1"),o=(St.test(f)?"&":"?")+"_="+kt+++o),v.url=f+o),v.ifModified&&(k.lastModified[f]&&T.setRequestHeader("If-Modified-Since",k.lastModified[f]),k.etag[f]&&T.setRequestHeader("If-None-Match",k.etag[f])),(v.data&&v.hasContent&&!1!==v.contentType||t.contentType)&&T.setRequestHeader("Content-Type",v.contentType),T.setRequestHeader("Accept",v.dataTypes[0]&&v.accepts[v.dataTypes[0]]?v.accepts[v.dataTypes[0]]+("*"!==v.dataTypes[0]?", "+$t+"; q=0.01":""):v.accepts["*"]),v.headers)T.setRequestHeader(i,v.headers[i]);if(v.beforeSend&&(!1===v.beforeSend.call(y,T,v)||h))return T.abort();if(u="abort",b.add(v.complete),T.done(v.success),T.fail(v.error),c=_t(Wt,v,t,T)){if(T.readyState=1,g&&m.trigger("ajaxSend",[T,v]),h)return T;v.async&&0<v.timeout&&(d=C.setTimeout(function(){T.abort("timeout")},v.timeout));try{h=!1,c.send(a,l)}catch(e){if(h)throw e;l(-1,e)}}else l(-1,"No Transport");function l(e,t,n,r){var i,o,a,s,u,l=t;h||(h=!0,d&&C.clearTimeout(d),c=void 0,p=r||"",T.readyState=0<e?4:0,i=200<=e&&e<300||304===e,n&&(s=function(e,t,n){var r,i,o,a,s=e.contents,u=e.dataTypes;while("*"===u[0])u.shift(),void 0===r&&(r=e.mimeType||t.getResponseHeader("Content-Type"));if(r)for(i in s)if(s[i]&&s[i].test(r)){u.unshift(i);break}if(u[0]in n)o=u[0];else{for(i in n){if(!u[0]||e.converters[i+" "+u[0]]){o=i;break}a||(a=i)}o=o||a}if(o)return o!==u[0]&&u.unshift(o),n[o]}(v,T,n)),s=function(e,t,n,r){var i,o,a,s,u,l={},c=e.dataTypes.slice();if(c[1])for(a in e.converters)l[a.toLowerCase()]=e.converters[a];o=c.shift();while(o)if(e.responseFields[o]&&(n[e.responseFields[o]]=t),!u&&r&&e.dataFilter&&(t=e.dataFilter(t,e.dataType)),u=o,o=c.shift())if("*"===o)o=u;else if("*"!==u&&u!==o){if(!(a=l[u+" "+o]||l["* "+o]))for(i in l)if((s=i.split(" "))[1]===o&&(a=l[u+" "+s[0]]||l["* "+s[0]])){!0===a?a=l[i]:!0!==l[i]&&(o=s[0],c.unshift(s[1]));break}if(!0!==a)if(a&&e["throws"])t=a(t);else try{t=a(t)}catch(e){return{state:"parsererror",error:a?e:"No conversion from "+u+" to "+o}}}return{state:"success",data:t}}(v,s,T,i),i?(v.ifModified&&((u=T.getResponseHeader("Last-Modified"))&&(k.lastModified[f]=u),(u=T.getResponseHeader("etag"))&&(k.etag[f]=u)),204===e||"HEAD"===v.type?l="nocontent":304===e?l="notmodified":(l=s.state,o=s.data,i=!(a=s.error))):(a=l,!e&&l||(l="error",e<0&&(e=0))),T.status=e,T.statusText=(t||l)+"",i?x.resolveWith(y,[o,l,T]):x.rejectWith(y,[T,l,a]),T.statusCode(w),w=void 0,g&&m.trigger(i?"ajaxSuccess":"ajaxError",[T,v,i?o:a]),b.fireWith(y,[T,l]),g&&(m.trigger("ajaxComplete",[T,v]),--k.active||k.event.trigger("ajaxStop")))}return T},getJSON:function(e,t,n){return k.get(e,t,n,"json")},getScript:function(e,t){return k.get(e,void 0,t,"script")}}),k.each(["get","post"],function(e,i){k[i]=function(e,t,n,r){return m(t)&&(r=r||n,n=t,t=void 0),k.ajax(k.extend({url:e,type:i,dataType:r,data:t,success:n},k.isPlainObject(e)&&e))}}),k._evalUrl=function(e,t){return k.ajax({url:e,type:"GET",dataType:"script",cache:!0,async:!1,global:!1,converters:{"text script":function(){}},dataFilter:function(e){k.globalEval(e,t)}})},k.fn.extend({wrapAll:function(e){var t;return this[0]&&(m(e)&&(e=e.call(this[0])),t=k(e,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&t.insertBefore(this[0]),t.map(function(){var e=this;while(e.firstElementChild)e=e.firstElementChild;return e}).append(this)),this},wrapInner:function(n){return m(n)?this.each(function(e){k(this).wrapInner(n.call(this,e))}):this.each(function(){var e=k(this),t=e.contents();t.length?t.wrapAll(n):e.append(n)})},wrap:function(t){var n=m(t);return this.each(function(e){k(this).wrapAll(n?t.call(this,e):t)})},unwrap:function(e){return this.parent(e).not("body").each(function(){k(this).replaceWith(this.childNodes)}),this}}),k.expr.pseudos.hidden=function(e){return!k.expr.pseudos.visible(e)},k.expr.pseudos.visible=function(e){return!!(e.offsetWidth||e.offsetHeight||e.getClientRects().length)},k.ajaxSettings.xhr=function(){try{return new C.XMLHttpRequest}catch(e){}};var Ut={0:200,1223:204},Xt=k.ajaxSettings.xhr();y.cors=!!Xt&&"withCredentials"in Xt,y.ajax=Xt=!!Xt,k.ajaxTransport(function(i){var o,a;if(y.cors||Xt&&!i.crossDomain)return{send:function(e,t){var n,r=i.xhr();if(r.open(i.type,i.url,i.async,i.username,i.password),i.xhrFields)for(n in i.xhrFields)r[n]=i.xhrFields[n];for(n in i.mimeType&&r.overrideMimeType&&r.overrideMimeType(i.mimeType),i.crossDomain||e["X-Requested-With"]||(e["X-Requested-With"]="XMLHttpRequest"),e)r.setRequestHeader(n,e[n]);o=function(e){return function(){o&&(o=a=r.onload=r.onerror=r.onabort=r.ontimeout=r.onreadystatechange=null,"abort"===e?r.abort():"error"===e?"number"!=typeof r.status?t(0,"error"):t(r.status,r.statusText):t(Ut[r.status]||r.status,r.statusText,"text"!==(r.responseType||"text")||"string"!=typeof r.responseText?{binary:r.response}:{text:r.responseText},r.getAllResponseHeaders()))}},r.onload=o(),a=r.onerror=r.ontimeout=o("error"),void 0!==r.onabort?r.onabort=a:r.onreadystatechange=function(){4===r.readyState&&C.setTimeout(function(){o&&a()})},o=o("abort");try{r.send(i.hasContent&&i.data||null)}catch(e){if(o)throw e}},abort:function(){o&&o()}}}),k.ajaxPrefilter(function(e){e.crossDomain&&(e.contents.script=!1)}),k.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/\b(?:java|ecma)script\b/},converters:{"text script":function(e){return k.globalEval(e),e}}}),k.ajaxPrefilter("script",function(e){void 0===e.cache&&(e.cache=!1),e.crossDomain&&(e.type="GET")}),k.ajaxTransport("script",function(n){var r,i;if(n.crossDomain||n.scriptAttrs)return{send:function(e,t){r=k("<script>").attr(n.scriptAttrs||{}).prop({charset:n.scriptCharset,src:n.url}).on("load error",i=function(e){r.remove(),i=null,e&&t("error"===e.type?404:200,e.type)}),E.head.appendChild(r[0])},abort:function(){i&&i()}}});var Vt,Gt=[],Yt=/(=)\?(?=&|$)|\?\?/;k.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=Gt.pop()||k.expando+"_"+kt++;return this[e]=!0,e}}),k.ajaxPrefilter("json jsonp",function(e,t,n){var r,i,o,a=!1!==e.jsonp&&(Yt.test(e.url)?"url":"string"==typeof e.data&&0===(e.contentType||"").indexOf("application/x-www-form-urlencoded")&&Yt.test(e.data)&&"data");if(a||"jsonp"===e.dataTypes[0])return r=e.jsonpCallback=m(e.jsonpCallback)?e.jsonpCallback():e.jsonpCallback,a?e[a]=e[a].replace(Yt,"$1"+r):!1!==e.jsonp&&(e.url+=(St.test(e.url)?"&":"?")+e.jsonp+"="+r),e.converters["script json"]=function(){return o||k.error(r+" was not called"),o[0]},e.dataTypes[0]="json",i=C[r],C[r]=function(){o=arguments},n.always(function(){void 0===i?k(C).removeProp(r):C[r]=i,e[r]&&(e.jsonpCallback=t.jsonpCallback,Gt.push(r)),o&&m(i)&&i(o[0]),o=i=void 0}),"script"}),y.createHTMLDocument=((Vt=E.implementation.createHTMLDocument("").body).innerHTML="<form></form><form></form>",2===Vt.childNodes.length),k.parseHTML=function(e,t,n){return"string"!=typeof e?[]:("boolean"==typeof t&&(n=t,t=!1),t||(y.createHTMLDocument?((r=(t=E.implementation.createHTMLDocument("")).createElement("base")).href=E.location.href,t.head.appendChild(r)):t=E),o=!n&&[],(i=D.exec(e))?[t.createElement(i[1])]:(i=we([e],t,o),o&&o.length&&k(o).remove(),k.merge([],i.childNodes)));var r,i,o},k.fn.load=function(e,t,n){var r,i,o,a=this,s=e.indexOf(" ");return-1<s&&(r=mt(e.slice(s)),e=e.slice(0,s)),m(t)?(n=t,t=void 0):t&&"object"==typeof t&&(i="POST"),0<a.length&&k.ajax({url:e,type:i||"GET",dataType:"html",data:t}).done(function(e){o=arguments,a.html(r?k("<div>").append(k.parseHTML(e)).find(r):e)}).always(n&&function(e,t){a.each(function(){n.apply(this,o||[e.responseText,t,e])})}),this},k.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(e,t){k.fn[t]=function(e){return this.on(t,e)}}),k.expr.pseudos.animated=function(t){return k.grep(k.timers,function(e){return t===e.elem}).length},k.offset={setOffset:function(e,t,n){var r,i,o,a,s,u,l=k.css(e,"position"),c=k(e),f={};"static"===l&&(e.style.position="relative"),s=c.offset(),o=k.css(e,"top"),u=k.css(e,"left"),("absolute"===l||"fixed"===l)&&-1<(o+u).indexOf("auto")?(a=(r=c.position()).top,i=r.left):(a=parseFloat(o)||0,i=parseFloat(u)||0),m(t)&&(t=t.call(e,n,k.extend({},s))),null!=t.top&&(f.top=t.top-s.top+a),null!=t.left&&(f.left=t.left-s.left+i),"using"in t?t.using.call(e,f):c.css(f)}},k.fn.extend({offset:function(t){if(arguments.length)return void 0===t?this:this.each(function(e){k.offset.setOffset(this,t,e)});var e,n,r=this[0];return r?r.getClientRects().length?(e=r.getBoundingClientRect(),n=r.ownerDocument.defaultView,{top:e.top+n.pageYOffset,left:e.left+n.pageXOffset}):{top:0,left:0}:void 0},position:function(){if(this[0]){var e,t,n,r=this[0],i={top:0,left:0};if("fixed"===k.css(r,"position"))t=r.getBoundingClientRect();else{t=this.offset(),n=r.ownerDocument,e=r.offsetParent||n.documentElement;while(e&&(e===n.body||e===n.documentElement)&&"static"===k.css(e,"position"))e=e.parentNode;e&&e!==r&&1===e.nodeType&&((i=k(e).offset()).top+=k.css(e,"borderTopWidth",!0),i.left+=k.css(e,"borderLeftWidth",!0))}return{top:t.top-i.top-k.css(r,"marginTop",!0),left:t.left-i.left-k.css(r,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var e=this.offsetParent;while(e&&"static"===k.css(e,"position"))e=e.offsetParent;return e||ie})}}),k.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(t,i){var o="pageYOffset"===i;k.fn[t]=function(e){return _(this,function(e,t,n){var r;if(x(e)?r=e:9===e.nodeType&&(r=e.defaultView),void 0===n)return r?r[i]:e[t];r?r.scrollTo(o?r.pageXOffset:n,o?n:r.pageYOffset):e[t]=n},t,e,arguments.length)}}),k.each(["top","left"],function(e,n){k.cssHooks[n]=ze(y.pixelPosition,function(e,t){if(t)return t=_e(e,n),$e.test(t)?k(e).position()[n]+"px":t})}),k.each({Height:"height",Width:"width"},function(a,s){k.each({padding:"inner"+a,content:s,"":"outer"+a},function(r,o){k.fn[o]=function(e,t){var n=arguments.length&&(r||"boolean"!=typeof e),i=r||(!0===e||!0===t?"margin":"border");return _(this,function(e,t,n){var r;return x(e)?0===o.indexOf("outer")?e["inner"+a]:e.document.documentElement["client"+a]:9===e.nodeType?(r=e.documentElement,Math.max(e.body["scroll"+a],r["scroll"+a],e.body["offset"+a],r["offset"+a],r["client"+a])):void 0===n?k.css(e,t,i):k.style(e,t,n,i)},s,n?e:void 0,n)}})}),k.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,n){k.fn[n]=function(e,t){return 0<arguments.length?this.on(n,null,e,t):this.trigger(n)}}),k.fn.extend({hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),k.fn.extend({bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)}}),k.proxy=function(e,t){var n,r,i;if("string"==typeof t&&(n=e[t],t=e,e=n),m(e))return r=s.call(arguments,2),(i=function(){return e.apply(t||this,r.concat(s.call(arguments)))}).guid=e.guid=e.guid||k.guid++,i},k.holdReady=function(e){e?k.readyWait++:k.ready(!0)},k.isArray=Array.isArray,k.parseJSON=JSON.parse,k.nodeName=A,k.isFunction=m,k.isWindow=x,k.camelCase=V,k.type=w,k.now=Date.now,k.isNumeric=function(e){var t=k.type(e);return("number"===t||"string"===t)&&!isNaN(e-parseFloat(e))},"function"==typeof define&&define.amd&&define("jquery",[],function(){return k});var Qt=C.jQuery,Jt=C.$;return k.noConflict=function(e){return C.$===k&&(C.$=Jt),e&&C.jQuery===k&&(C.jQuery=Qt),k},e||(C.jQuery=C.$=k),k});
+/*! jQuery UI - v1.12.1 - 2019-01-27
+* http://jqueryui.com
+* Includes: widget.js, position.js, data.js, disable-selection.js, focusable.js, form-reset-mixin.js, jquery-1-7.js, keycode.js, labels.js, scroll-parent.js, tabbable.js, unique-id.js, widgets/resizable.js, widgets/mouse.js
+* Copyright jQuery Foundation and other contributors; Licensed MIT */
+
+(function(t){"function"==typeof define&&define.amd?define(["jquery"],t):t(jQuery)})(function(t){function e(t){for(var e=t.css("visibility");"inherit"===e;)t=t.parent(),e=t.css("visibility");return"hidden"!==e}t.ui=t.ui||{},t.ui.version="1.12.1";var i=0,s=Array.prototype.slice;t.cleanData=function(e){return function(i){var s,n,o;for(o=0;null!=(n=i[o]);o++)try{s=t._data(n,"events"),s&&s.remove&&t(n).triggerHandler("remove")}catch(a){}e(i)}}(t.cleanData),t.widget=function(e,i,s){var n,o,a,r={},h=e.split(".")[0];e=e.split(".")[1];var l=h+"-"+e;return s||(s=i,i=t.Widget),t.isArray(s)&&(s=t.extend.apply(null,[{}].concat(s))),t.expr[":"][l.toLowerCase()]=function(e){return!!t.data(e,l)},t[h]=t[h]||{},n=t[h][e],o=t[h][e]=function(t,e){return this._createWidget?(arguments.length&&this._createWidget(t,e),void 0):new o(t,e)},t.extend(o,n,{version:s.version,_proto:t.extend({},s),_childConstructors:[]}),a=new i,a.options=t.widget.extend({},a.options),t.each(s,function(e,s){return t.isFunction(s)?(r[e]=function(){function t(){return i.prototype[e].apply(this,arguments)}function n(t){return i.prototype[e].apply(this,t)}return function(){var e,i=this._super,o=this._superApply;return this._super=t,this._superApply=n,e=s.apply(this,arguments),this._super=i,this._superApply=o,e}}(),void 0):(r[e]=s,void 0)}),o.prototype=t.widget.extend(a,{widgetEventPrefix:n?a.widgetEventPrefix||e:e},r,{constructor:o,namespace:h,widgetName:e,widgetFullName:l}),n?(t.each(n._childConstructors,function(e,i){var s=i.prototype;t.widget(s.namespace+"."+s.widgetName,o,i._proto)}),delete n._childConstructors):i._childConstructors.push(o),t.widget.bridge(e,o),o},t.widget.extend=function(e){for(var i,n,o=s.call(arguments,1),a=0,r=o.length;r>a;a++)for(i in o[a])n=o[a][i],o[a].hasOwnProperty(i)&&void 0!==n&&(e[i]=t.isPlainObject(n)?t.isPlainObject(e[i])?t.widget.extend({},e[i],n):t.widget.extend({},n):n);return e},t.widget.bridge=function(e,i){var n=i.prototype.widgetFullName||e;t.fn[e]=function(o){var a="string"==typeof o,r=s.call(arguments,1),h=this;return a?this.length||"instance"!==o?this.each(function(){var i,s=t.data(this,n);return"instance"===o?(h=s,!1):s?t.isFunction(s[o])&&"_"!==o.charAt(0)?(i=s[o].apply(s,r),i!==s&&void 0!==i?(h=i&&i.jquery?h.pushStack(i.get()):i,!1):void 0):t.error("no such method '"+o+"' for "+e+" widget instance"):t.error("cannot call methods on "+e+" prior to initialization; "+"attempted to call method '"+o+"'")}):h=void 0:(r.length&&(o=t.widget.extend.apply(null,[o].concat(r))),this.each(function(){var e=t.data(this,n);e?(e.option(o||{}),e._init&&e._init()):t.data(this,n,new i(o,this))})),h}},t.Widget=function(){},t.Widget._childConstructors=[],t.Widget.prototype={widgetName:"widget",widgetEventPrefix:"",defaultElement:"<div>",options:{classes:{},disabled:!1,create:null},_createWidget:function(e,s){s=t(s||this.defaultElement||this)[0],this.element=t(s),this.uuid=i++,this.eventNamespace="."+this.widgetName+this.uuid,this.bindings=t(),this.hoverable=t(),this.focusable=t(),this.classesElementLookup={},s!==this&&(t.data(s,this.widgetFullName,this),this._on(!0,this.element,{remove:function(t){t.target===s&&this.destroy()}}),this.document=t(s.style?s.ownerDocument:s.document||s),this.window=t(this.document[0].defaultView||this.document[0].parentWindow)),this.options=t.widget.extend({},this.options,this._getCreateOptions(),e),this._create(),this.options.disabled&&this._setOptionDisabled(this.options.disabled),this._trigger("create",null,this._getCreateEventData()),this._init()},_getCreateOptions:function(){return{}},_getCreateEventData:t.noop,_create:t.noop,_init:t.noop,destroy:function(){var e=this;this._destroy(),t.each(this.classesElementLookup,function(t,i){e._removeClass(i,t)}),this.element.off(this.eventNamespace).removeData(this.widgetFullName),this.widget().off(this.eventNamespace).removeAttr("aria-disabled"),this.bindings.off(this.eventNamespace)},_destroy:t.noop,widget:function(){return this.element},option:function(e,i){var s,n,o,a=e;if(0===arguments.length)return t.widget.extend({},this.options);if("string"==typeof e)if(a={},s=e.split("."),e=s.shift(),s.length){for(n=a[e]=t.widget.extend({},this.options[e]),o=0;s.length-1>o;o++)n[s[o]]=n[s[o]]||{},n=n[s[o]];if(e=s.pop(),1===arguments.length)return void 0===n[e]?null:n[e];n[e]=i}else{if(1===arguments.length)return void 0===this.options[e]?null:this.options[e];a[e]=i}return this._setOptions(a),this},_setOptions:function(t){var e;for(e in t)this._setOption(e,t[e]);return this},_setOption:function(t,e){return"classes"===t&&this._setOptionClasses(e),this.options[t]=e,"disabled"===t&&this._setOptionDisabled(e),this},_setOptionClasses:function(e){var i,s,n;for(i in e)n=this.classesElementLookup[i],e[i]!==this.options.classes[i]&&n&&n.length&&(s=t(n.get()),this._removeClass(n,i),s.addClass(this._classes({element:s,keys:i,classes:e,add:!0})))},_setOptionDisabled:function(t){this._toggleClass(this.widget(),this.widgetFullName+"-disabled",null,!!t),t&&(this._removeClass(this.hoverable,null,"ui-state-hover"),this._removeClass(this.focusable,null,"ui-state-focus"))},enable:function(){return this._setOptions({disabled:!1})},disable:function(){return this._setOptions({disabled:!0})},_classes:function(e){function i(i,o){var a,r;for(r=0;i.length>r;r++)a=n.classesElementLookup[i[r]]||t(),a=e.add?t(t.unique(a.get().concat(e.element.get()))):t(a.not(e.element).get()),n.classesElementLookup[i[r]]=a,s.push(i[r]),o&&e.classes[i[r]]&&s.push(e.classes[i[r]])}var s=[],n=this;return e=t.extend({element:this.element,classes:this.options.classes||{}},e),this._on(e.element,{remove:"_untrackClassesElement"}),e.keys&&i(e.keys.match(/\S+/g)||[],!0),e.extra&&i(e.extra.match(/\S+/g)||[]),s.join(" ")},_untrackClassesElement:function(e){var i=this;t.each(i.classesElementLookup,function(s,n){-1!==t.inArray(e.target,n)&&(i.classesElementLookup[s]=t(n.not(e.target).get()))})},_removeClass:function(t,e,i){return this._toggleClass(t,e,i,!1)},_addClass:function(t,e,i){return this._toggleClass(t,e,i,!0)},_toggleClass:function(t,e,i,s){s="boolean"==typeof s?s:i;var n="string"==typeof t||null===t,o={extra:n?e:i,keys:n?t:e,element:n?this.element:t,add:s};return o.element.toggleClass(this._classes(o),s),this},_on:function(e,i,s){var n,o=this;"boolean"!=typeof e&&(s=i,i=e,e=!1),s?(i=n=t(i),this.bindings=this.bindings.add(i)):(s=i,i=this.element,n=this.widget()),t.each(s,function(s,a){function r(){return e||o.options.disabled!==!0&&!t(this).hasClass("ui-state-disabled")?("string"==typeof a?o[a]:a).apply(o,arguments):void 0}"string"!=typeof a&&(r.guid=a.guid=a.guid||r.guid||t.guid++);var h=s.match(/^([\w:-]*)\s*(.*)$/),l=h[1]+o.eventNamespace,c=h[2];c?n.on(l,c,r):i.on(l,r)})},_off:function(e,i){i=(i||"").split(" ").join(this.eventNamespace+" ")+this.eventNamespace,e.off(i).off(i),this.bindings=t(this.bindings.not(e).get()),this.focusable=t(this.focusable.not(e).get()),this.hoverable=t(this.hoverable.not(e).get())},_delay:function(t,e){function i(){return("string"==typeof t?s[t]:t).apply(s,arguments)}var s=this;return setTimeout(i,e||0)},_hoverable:function(e){this.hoverable=this.hoverable.add(e),this._on(e,{mouseenter:function(e){this._addClass(t(e.currentTarget),null,"ui-state-hover")},mouseleave:function(e){this._removeClass(t(e.currentTarget),null,"ui-state-hover")}})},_focusable:function(e){this.focusable=this.focusable.add(e),this._on(e,{focusin:function(e){this._addClass(t(e.currentTarget),null,"ui-state-focus")},focusout:function(e){this._removeClass(t(e.currentTarget),null,"ui-state-focus")}})},_trigger:function(e,i,s){var n,o,a=this.options[e];if(s=s||{},i=t.Event(i),i.type=(e===this.widgetEventPrefix?e:this.widgetEventPrefix+e).toLowerCase(),i.target=this.element[0],o=i.originalEvent)for(n in o)n in i||(i[n]=o[n]);return this.element.trigger(i,s),!(t.isFunction(a)&&a.apply(this.element[0],[i].concat(s))===!1||i.isDefaultPrevented())}},t.each({show:"fadeIn",hide:"fadeOut"},function(e,i){t.Widget.prototype["_"+e]=function(s,n,o){"string"==typeof n&&(n={effect:n});var a,r=n?n===!0||"number"==typeof n?i:n.effect||i:e;n=n||{},"number"==typeof n&&(n={duration:n}),a=!t.isEmptyObject(n),n.complete=o,n.delay&&s.delay(n.delay),a&&t.effects&&t.effects.effect[r]?s[e](n):r!==e&&s[r]?s[r](n.duration,n.easing,o):s.queue(function(i){t(this)[e](),o&&o.call(s[0]),i()})}}),t.widget,function(){function e(t,e,i){return[parseFloat(t[0])*(u.test(t[0])?e/100:1),parseFloat(t[1])*(u.test(t[1])?i/100:1)]}function i(e,i){return parseInt(t.css(e,i),10)||0}function s(e){var i=e[0];return 9===i.nodeType?{width:e.width(),height:e.height(),offset:{top:0,left:0}}:t.isWindow(i)?{width:e.width(),height:e.height(),offset:{top:e.scrollTop(),left:e.scrollLeft()}}:i.preventDefault?{width:0,height:0,offset:{top:i.pageY,left:i.pageX}}:{width:e.outerWidth(),height:e.outerHeight(),offset:e.offset()}}var n,o=Math.max,a=Math.abs,r=/left|center|right/,h=/top|center|bottom/,l=/[\+\-]\d+(\.[\d]+)?%?/,c=/^\w+/,u=/%$/,d=t.fn.position;t.position={scrollbarWidth:function(){if(void 0!==n)return n;var e,i,s=t("<div style='display:block;position:absolute;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>"),o=s.children()[0];return t("body").append(s),e=o.offsetWidth,s.css("overflow","scroll"),i=o.offsetWidth,e===i&&(i=s[0].clientWidth),s.remove(),n=e-i},getScrollInfo:function(e){var i=e.isWindow||e.isDocument?"":e.element.css("overflow-x"),s=e.isWindow||e.isDocument?"":e.element.css("overflow-y"),n="scroll"===i||"auto"===i&&e.width<e.element[0].scrollWidth,o="scroll"===s||"auto"===s&&e.height<e.element[0].scrollHeight;return{width:o?t.position.scrollbarWidth():0,height:n?t.position.scrollbarWidth():0}},getWithinInfo:function(e){var i=t(e||window),s=t.isWindow(i[0]),n=!!i[0]&&9===i[0].nodeType,o=!s&&!n;return{element:i,isWindow:s,isDocument:n,offset:o?t(e).offset():{left:0,top:0},scrollLeft:i.scrollLeft(),scrollTop:i.scrollTop(),width:i.outerWidth(),height:i.outerHeight()}}},t.fn.position=function(n){if(!n||!n.of)return d.apply(this,arguments);n=t.extend({},n);var u,p,f,m,g,_,v=t(n.of),b=t.position.getWithinInfo(n.within),y=t.position.getScrollInfo(b),w=(n.collision||"flip").split(" "),x={};return _=s(v),v[0].preventDefault&&(n.at="left top"),p=_.width,f=_.height,m=_.offset,g=t.extend({},m),t.each(["my","at"],function(){var t,e,i=(n[this]||"").split(" ");1===i.length&&(i=r.test(i[0])?i.concat(["center"]):h.test(i[0])?["center"].concat(i):["center","center"]),i[0]=r.test(i[0])?i[0]:"center",i[1]=h.test(i[1])?i[1]:"center",t=l.exec(i[0]),e=l.exec(i[1]),x[this]=[t?t[0]:0,e?e[0]:0],n[this]=[c.exec(i[0])[0],c.exec(i[1])[0]]}),1===w.length&&(w[1]=w[0]),"right"===n.at[0]?g.left+=p:"center"===n.at[0]&&(g.left+=p/2),"bottom"===n.at[1]?g.top+=f:"center"===n.at[1]&&(g.top+=f/2),u=e(x.at,p,f),g.left+=u[0],g.top+=u[1],this.each(function(){var s,r,h=t(this),l=h.outerWidth(),c=h.outerHeight(),d=i(this,"marginLeft"),_=i(this,"marginTop"),k=l+d+i(this,"marginRight")+y.width,C=c+_+i(this,"marginBottom")+y.height,D=t.extend({},g),T=e(x.my,h.outerWidth(),h.outerHeight());"right"===n.my[0]?D.left-=l:"center"===n.my[0]&&(D.left-=l/2),"bottom"===n.my[1]?D.top-=c:"center"===n.my[1]&&(D.top-=c/2),D.left+=T[0],D.top+=T[1],s={marginLeft:d,marginTop:_},t.each(["left","top"],function(e,i){t.ui.position[w[e]]&&t.ui.position[w[e]][i](D,{targetWidth:p,targetHeight:f,elemWidth:l,elemHeight:c,collisionPosition:s,collisionWidth:k,collisionHeight:C,offset:[u[0]+T[0],u[1]+T[1]],my:n.my,at:n.at,within:b,elem:h})}),n.using&&(r=function(t){var e=m.left-D.left,i=e+p-l,s=m.top-D.top,r=s+f-c,u={target:{element:v,left:m.left,top:m.top,width:p,height:f},element:{element:h,left:D.left,top:D.top,width:l,height:c},horizontal:0>i?"left":e>0?"right":"center",vertical:0>r?"top":s>0?"bottom":"middle"};l>p&&p>a(e+i)&&(u.horizontal="center"),c>f&&f>a(s+r)&&(u.vertical="middle"),u.important=o(a(e),a(i))>o(a(s),a(r))?"horizontal":"vertical",n.using.call(this,t,u)}),h.offset(t.extend(D,{using:r}))})},t.ui.position={fit:{left:function(t,e){var i,s=e.within,n=s.isWindow?s.scrollLeft:s.offset.left,a=s.width,r=t.left-e.collisionPosition.marginLeft,h=n-r,l=r+e.collisionWidth-a-n;e.collisionWidth>a?h>0&&0>=l?(i=t.left+h+e.collisionWidth-a-n,t.left+=h-i):t.left=l>0&&0>=h?n:h>l?n+a-e.collisionWidth:n:h>0?t.left+=h:l>0?t.left-=l:t.left=o(t.left-r,t.left)},top:function(t,e){var i,s=e.within,n=s.isWindow?s.scrollTop:s.offset.top,a=e.within.height,r=t.top-e.collisionPosition.marginTop,h=n-r,l=r+e.collisionHeight-a-n;e.collisionHeight>a?h>0&&0>=l?(i=t.top+h+e.collisionHeight-a-n,t.top+=h-i):t.top=l>0&&0>=h?n:h>l?n+a-e.collisionHeight:n:h>0?t.top+=h:l>0?t.top-=l:t.top=o(t.top-r,t.top)}},flip:{left:function(t,e){var i,s,n=e.within,o=n.offset.left+n.scrollLeft,r=n.width,h=n.isWindow?n.scrollLeft:n.offset.left,l=t.left-e.collisionPosition.marginLeft,c=l-h,u=l+e.collisionWidth-r-h,d="left"===e.my[0]?-e.elemWidth:"right"===e.my[0]?e.elemWidth:0,p="left"===e.at[0]?e.targetWidth:"right"===e.at[0]?-e.targetWidth:0,f=-2*e.offset[0];0>c?(i=t.left+d+p+f+e.collisionWidth-r-o,(0>i||a(c)>i)&&(t.left+=d+p+f)):u>0&&(s=t.left-e.collisionPosition.marginLeft+d+p+f-h,(s>0||u>a(s))&&(t.left+=d+p+f))},top:function(t,e){var i,s,n=e.within,o=n.offset.top+n.scrollTop,r=n.height,h=n.isWindow?n.scrollTop:n.offset.top,l=t.top-e.collisionPosition.marginTop,c=l-h,u=l+e.collisionHeight-r-h,d="top"===e.my[1],p=d?-e.elemHeight:"bottom"===e.my[1]?e.elemHeight:0,f="top"===e.at[1]?e.targetHeight:"bottom"===e.at[1]?-e.targetHeight:0,m=-2*e.offset[1];0>c?(s=t.top+p+f+m+e.collisionHeight-r-o,(0>s||a(c)>s)&&(t.top+=p+f+m)):u>0&&(i=t.top-e.collisionPosition.marginTop+p+f+m-h,(i>0||u>a(i))&&(t.top+=p+f+m))}},flipfit:{left:function(){t.ui.position.flip.left.apply(this,arguments),t.ui.position.fit.left.apply(this,arguments)},top:function(){t.ui.position.flip.top.apply(this,arguments),t.ui.position.fit.top.apply(this,arguments)}}}}(),t.ui.position,t.extend(t.expr[":"],{data:t.expr.createPseudo?t.expr.createPseudo(function(e){return function(i){return!!t.data(i,e)}}):function(e,i,s){return!!t.data(e,s[3])}}),t.fn.extend({disableSelection:function(){var t="onselectstart"in document.createElement("div")?"selectstart":"mousedown";return function(){return this.on(t+".ui-disableSelection",function(t){t.preventDefault()})}}(),enableSelection:function(){return this.off(".ui-disableSelection")}}),t.ui.focusable=function(i,s){var n,o,a,r,h,l=i.nodeName.toLowerCase();return"area"===l?(n=i.parentNode,o=n.name,i.href&&o&&"map"===n.nodeName.toLowerCase()?(a=t("img[usemap='#"+o+"']"),a.length>0&&a.is(":visible")):!1):(/^(input|select|textarea|button|object)$/.test(l)?(r=!i.disabled,r&&(h=t(i).closest("fieldset")[0],h&&(r=!h.disabled))):r="a"===l?i.href||s:s,r&&t(i).is(":visible")&&e(t(i)))},t.extend(t.expr[":"],{focusable:function(e){return t.ui.focusable(e,null!=t.attr(e,"tabindex"))}}),t.ui.focusable,t.fn.form=function(){return"string"==typeof this[0].form?this.closest("form"):t(this[0].form)},t.ui.formResetMixin={_formResetHandler:function(){var e=t(this);setTimeout(function(){var i=e.data("ui-form-reset-instances");t.each(i,function(){this.refresh()})})},_bindFormResetHandler:function(){if(this.form=this.element.form(),this.form.length){var t=this.form.data("ui-form-reset-instances")||[];t.length||this.form.on("reset.ui-form-reset",this._formResetHandler),t.push(this),this.form.data("ui-form-reset-instances",t)}},_unbindFormResetHandler:function(){if(this.form.length){var e=this.form.data("ui-form-reset-instances");e.splice(t.inArray(this,e),1),e.length?this.form.data("ui-form-reset-instances",e):this.form.removeData("ui-form-reset-instances").off("reset.ui-form-reset")}}},"1.7"===t.fn.jquery.substring(0,3)&&(t.each(["Width","Height"],function(e,i){function s(e,i,s,o){return t.each(n,function(){i-=parseFloat(t.css(e,"padding"+this))||0,s&&(i-=parseFloat(t.css(e,"border"+this+"Width"))||0),o&&(i-=parseFloat(t.css(e,"margin"+this))||0)}),i}var n="Width"===i?["Left","Right"]:["Top","Bottom"],o=i.toLowerCase(),a={innerWidth:t.fn.innerWidth,innerHeight:t.fn.innerHeight,outerWidth:t.fn.outerWidth,outerHeight:t.fn.outerHeight};t.fn["inner"+i]=function(e){return void 0===e?a["inner"+i].call(this):this.each(function(){t(this).css(o,s(this,e)+"px")})},t.fn["outer"+i]=function(e,n){return"number"!=typeof e?a["outer"+i].call(this,e):this.each(function(){t(this).css(o,s(this,e,!0,n)+"px")})}}),t.fn.addBack=function(t){return this.add(null==t?this.prevObject:this.prevObject.filter(t))}),t.ui.keyCode={BACKSPACE:8,COMMA:188,DELETE:46,DOWN:40,END:35,ENTER:13,ESCAPE:27,HOME:36,LEFT:37,PAGE_DOWN:34,PAGE_UP:33,PERIOD:190,RIGHT:39,SPACE:32,TAB:9,UP:38},t.ui.escapeSelector=function(){var t=/([!"#$%&'()*+,./:;<=>?@[\]^`{|}~])/g;return function(e){return e.replace(t,"\\$1")}}(),t.fn.labels=function(){var e,i,s,n,o;return this[0].labels&&this[0].labels.length?this.pushStack(this[0].labels):(n=this.eq(0).parents("label"),s=this.attr("id"),s&&(e=this.eq(0).parents().last(),o=e.add(e.length?e.siblings():this.siblings()),i="label[for='"+t.ui.escapeSelector(s)+"']",n=n.add(o.find(i).addBack(i))),this.pushStack(n))},t.fn.scrollParent=function(e){var i=this.css("position"),s="absolute"===i,n=e?/(auto|scroll|hidden)/:/(auto|scroll)/,o=this.parents().filter(function(){var e=t(this);return s&&"static"===e.css("position")?!1:n.test(e.css("overflow")+e.css("overflow-y")+e.css("overflow-x"))}).eq(0);return"fixed"!==i&&o.length?o:t(this[0].ownerDocument||document)},t.extend(t.expr[":"],{tabbable:function(e){var i=t.attr(e,"tabindex"),s=null!=i;return(!s||i>=0)&&t.ui.focusable(e,s)}}),t.fn.extend({uniqueId:function(){var t=0;return function(){return this.each(function(){this.id||(this.id="ui-id-"+ ++t)})}}(),removeUniqueId:function(){return this.each(function(){/^ui-id-\d+$/.test(this.id)&&t(this).removeAttr("id")})}}),t.ui.ie=!!/msie [\w.]+/.exec(navigator.userAgent.toLowerCase());var n=!1;t(document).on("mouseup",function(){n=!1}),t.widget("ui.mouse",{version:"1.12.1",options:{cancel:"input, textarea, button, select, option",distance:1,delay:0},_mouseInit:function(){var e=this;this.element.on("mousedown."+this.widgetName,function(t){return e._mouseDown(t)}).on("click."+this.widgetName,function(i){return!0===t.data(i.target,e.widgetName+".preventClickEvent")?(t.removeData(i.target,e.widgetName+".preventClickEvent"),i.stopImmediatePropagation(),!1):void 0}),this.started=!1},_mouseDestroy:function(){this.element.off("."+this.widgetName),this._mouseMoveDelegate&&this.document.off("mousemove."+this.widgetName,this._mouseMoveDelegate).off("mouseup."+this.widgetName,this._mouseUpDelegate)},_mouseDown:function(e){if(!n){this._mouseMoved=!1,this._mouseStarted&&this._mouseUp(e),this._mouseDownEvent=e;var i=this,s=1===e.which,o="string"==typeof this.options.cancel&&e.target.nodeName?t(e.target).closest(this.options.cancel).length:!1;return s&&!o&&this._mouseCapture(e)?(this.mouseDelayMet=!this.options.delay,this.mouseDelayMet||(this._mouseDelayTimer=setTimeout(function(){i.mouseDelayMet=!0},this.options.delay)),this._mouseDistanceMet(e)&&this._mouseDelayMet(e)&&(this._mouseStarted=this._mouseStart(e)!==!1,!this._mouseStarted)?(e.preventDefault(),!0):(!0===t.data(e.target,this.widgetName+".preventClickEvent")&&t.removeData(e.target,this.widgetName+".preventClickEvent"),this._mouseMoveDelegate=function(t){return i._mouseMove(t)},this._mouseUpDelegate=function(t){return i._mouseUp(t)},this.document.on("mousemove."+this.widgetName,this._mouseMoveDelegate).on("mouseup."+this.widgetName,this._mouseUpDelegate),e.preventDefault(),n=!0,!0)):!0}},_mouseMove:function(e){if(this._mouseMoved){if(t.ui.ie&&(!document.documentMode||9>document.documentMode)&&!e.button)return this._mouseUp(e);if(!e.which)if(e.originalEvent.altKey||e.originalEvent.ctrlKey||e.originalEvent.metaKey||e.originalEvent.shiftKey)this.ignoreMissingWhich=!0;else if(!this.ignoreMissingWhich)return this._mouseUp(e)}return(e.which||e.button)&&(this._mouseMoved=!0),this._mouseStarted?(this._mouseDrag(e),e.preventDefault()):(this._mouseDistanceMet(e)&&this._mouseDelayMet(e)&&(this._mouseStarted=this._mouseStart(this._mouseDownEvent,e)!==!1,this._mouseStarted?this._mouseDrag(e):this._mouseUp(e)),!this._mouseStarted)},_mouseUp:function(e){this.document.off("mousemove."+this.widgetName,this._mouseMoveDelegate).off("mouseup."+this.widgetName,this._mouseUpDelegate),this._mouseStarted&&(this._mouseStarted=!1,e.target===this._mouseDownEvent.target&&t.data(e.target,this.widgetName+".preventClickEvent",!0),this._mouseStop(e)),this._mouseDelayTimer&&(clearTimeout(this._mouseDelayTimer),delete this._mouseDelayTimer),this.ignoreMissingWhich=!1,n=!1,e.preventDefault()},_mouseDistanceMet:function(t){return Math.max(Math.abs(this._mouseDownEvent.pageX-t.pageX),Math.abs(this._mouseDownEvent.pageY-t.pageY))>=this.options.distance},_mouseDelayMet:function(){return this.mouseDelayMet},_mouseStart:function(){},_mouseDrag:function(){},_mouseStop:function(){},_mouseCapture:function(){return!0}}),t.ui.plugin={add:function(e,i,s){var n,o=t.ui[e].prototype;for(n in s)o.plugins[n]=o.plugins[n]||[],o.plugins[n].push([i,s[n]])},call:function(t,e,i,s){var n,o=t.plugins[e];if(o&&(s||t.element[0].parentNode&&11!==t.element[0].parentNode.nodeType))for(n=0;o.length>n;n++)t.options[o[n][0]]&&o[n][1].apply(t.element,i)}},t.widget("ui.resizable",t.ui.mouse,{version:"1.12.1",widgetEventPrefix:"resize",options:{alsoResize:!1,animate:!1,animateDuration:"slow",animateEasing:"swing",aspectRatio:!1,autoHide:!1,classes:{"ui-resizable-se":"ui-icon ui-icon-gripsmall-diagonal-se"},containment:!1,ghost:!1,grid:!1,handles:"e,s,se",helper:!1,maxHeight:null,maxWidth:null,minHeight:10,minWidth:10,zIndex:90,resize:null,start:null,stop:null},_num:function(t){return parseFloat(t)||0},_isNumber:function(t){return!isNaN(parseFloat(t))},_hasScroll:function(e,i){if("hidden"===t(e).css("overflow"))return!1;var s=i&&"left"===i?"scrollLeft":"scrollTop",n=!1;return e[s]>0?!0:(e[s]=1,n=e[s]>0,e[s]=0,n)},_create:function(){var e,i=this.options,s=this;this._addClass("ui-resizable"),t.extend(this,{_aspectRatio:!!i.aspectRatio,aspectRatio:i.aspectRatio,originalElement:this.element,_proportionallyResizeElements:[],_helper:i.helper||i.ghost||i.animate?i.helper||"ui-resizable-helper":null}),this.element[0].nodeName.match(/^(canvas|textarea|input|select|button|img)$/i)&&(this.element.wrap(t("<div class='ui-wrapper' style='overflow: hidden;'></div>").css({position:this.element.css("position"),width:this.element.outerWidth(),height:this.element.outerHeight(),top:this.element.css("top"),left:this.element.css("left")})),this.element=this.element.parent().data("ui-resizable",this.element.resizable("instance")),this.elementIsWrapper=!0,e={marginTop:this.originalElement.css("marginTop"),marginRight:this.originalElement.css("marginRight"),marginBottom:this.originalElement.css("marginBottom"),marginLeft:this.originalElement.css("marginLeft")},this.element.css(e),this.originalElement.css("margin",0),this.originalResizeStyle=this.originalElement.css("resize"),this.originalElement.css("resize","none"),this._proportionallyResizeElements.push(this.originalElement.css({position:"static",zoom:1,display:"block"})),this.originalElement.css(e),this._proportionallyResize()),this._setupHandles(),i.autoHide&&t(this.element).on("mouseenter",function(){i.disabled||(s._removeClass("ui-resizable-autohide"),s._handles.show())}).on("mouseleave",function(){i.disabled||s.resizing||(s._addClass("ui-resizable-autohide"),s._handles.hide())}),this._mouseInit()},_destroy:function(){this._mouseDestroy();var e,i=function(e){t(e).removeData("resizable").removeData("ui-resizable").off(".resizable").find(".ui-resizable-handle").remove()};return this.elementIsWrapper&&(i(this.element),e=this.element,this.originalElement.css({position:e.css("position"),width:e.outerWidth(),height:e.outerHeight(),top:e.css("top"),left:e.css("left")}).insertAfter(e),e.remove()),this.originalElement.css("resize",this.originalResizeStyle),i(this.originalElement),this},_setOption:function(t,e){switch(this._super(t,e),t){case"handles":this._removeHandles(),this._setupHandles();break;default:}},_setupHandles:function(){var e,i,s,n,o,a=this.options,r=this;if(this.handles=a.handles||(t(".ui-resizable-handle",this.element).length?{n:".ui-resizable-n",e:".ui-resizable-e",s:".ui-resizable-s",w:".ui-resizable-w",se:".ui-resizable-se",sw:".ui-resizable-sw",ne:".ui-resizable-ne",nw:".ui-resizable-nw"}:"e,s,se"),this._handles=t(),this.handles.constructor===String)for("all"===this.handles&&(this.handles="n,e,s,w,se,sw,ne,nw"),s=this.handles.split(","),this.handles={},i=0;s.length>i;i++)e=t.trim(s[i]),n="ui-resizable-"+e,o=t("<div>"),this._addClass(o,"ui-resizable-handle "+n),o.css({zIndex:a.zIndex}),this.handles[e]=".ui-resizable-"+e,this.element.append(o);this._renderAxis=function(e){var i,s,n,o;e=e||this.element;for(i in this.handles)this.handles[i].constructor===String?this.handles[i]=this.element.children(this.handles[i]).first().show():(this.handles[i].jquery||this.handles[i].nodeType)&&(this.handles[i]=t(this.handles[i]),this._on(this.handles[i],{mousedown:r._mouseDown})),this.elementIsWrapper&&this.originalElement[0].nodeName.match(/^(textarea|input|select|button)$/i)&&(s=t(this.handles[i],this.element),o=/sw|ne|nw|se|n|s/.test(i)?s.outerHeight():s.outerWidth(),n=["padding",/ne|nw|n/.test(i)?"Top":/se|sw|s/.test(i)?"Bottom":/^e$/.test(i)?"Right":"Left"].join(""),e.css(n,o),this._proportionallyResize()),this._handles=this._handles.add(this.handles[i])},this._renderAxis(this.element),this._handles=this._handles.add(this.element.find(".ui-resizable-handle")),this._handles.disableSelection(),this._handles.on("mouseover",function(){r.resizing||(this.className&&(o=this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i)),r.axis=o&&o[1]?o[1]:"se")}),a.autoHide&&(this._handles.hide(),this._addClass("ui-resizable-autohide"))},_removeHandles:function(){this._handles.remove()},_mouseCapture:function(e){var i,s,n=!1;for(i in this.handles)s=t(this.handles[i])[0],(s===e.target||t.contains(s,e.target))&&(n=!0);return!this.options.disabled&&n},_mouseStart:function(e){var i,s,n,o=this.options,a=this.element;return this.resizing=!0,this._renderProxy(),i=this._num(this.helper.css("left")),s=this._num(this.helper.css("top")),o.containment&&(i+=t(o.containment).scrollLeft()||0,s+=t(o.containment).scrollTop()||0),this.offset=this.helper.offset(),this.position={left:i,top:s},this.size=this._helper?{width:this.helper.width(),height:this.helper.height()}:{width:a.width(),height:a.height()},this.originalSize=this._helper?{width:a.outerWidth(),height:a.outerHeight()}:{width:a.width(),height:a.height()},this.sizeDiff={width:a.outerWidth()-a.width(),height:a.outerHeight()-a.height()},this.originalPosition={left:i,top:s},this.originalMousePosition={left:e.pageX,top:e.pageY},this.aspectRatio="number"==typeof o.aspectRatio?o.aspectRatio:this.originalSize.width/this.originalSize.height||1,n=t(".ui-resizable-"+this.axis).css("cursor"),t("body").css("cursor","auto"===n?this.axis+"-resize":n),this._addClass("ui-resizable-resizing"),this._propagate("start",e),!0},_mouseDrag:function(e){var i,s,n=this.originalMousePosition,o=this.axis,a=e.pageX-n.left||0,r=e.pageY-n.top||0,h=this._change[o];return this._updatePrevProperties(),h?(i=h.apply(this,[e,a,r]),this._updateVirtualBoundaries(e.shiftKey),(this._aspectRatio||e.shiftKey)&&(i=this._updateRatio(i,e)),i=this._respectSize(i,e),this._updateCache(i),this._propagate("resize",e),s=this._applyChanges(),!this._helper&&this._proportionallyResizeElements.length&&this._proportionallyResize(),t.isEmptyObject(s)||(this._updatePrevProperties(),this._trigger("resize",e,this.ui()),this._applyChanges()),!1):!1},_mouseStop:function(e){this.resizing=!1;var i,s,n,o,a,r,h,l=this.options,c=this;return this._helper&&(i=this._proportionallyResizeElements,s=i.length&&/textarea/i.test(i[0].nodeName),n=s&&this._hasScroll(i[0],"left")?0:c.sizeDiff.height,o=s?0:c.sizeDiff.width,a={width:c.helper.width()-o,height:c.helper.height()-n},r=parseFloat(c.element.css("left"))+(c.position.left-c.originalPosition.left)||null,h=parseFloat(c.element.css("top"))+(c.position.top-c.originalPosition.top)||null,l.animate||this.element.css(t.extend(a,{top:h,left:r})),c.helper.height(c.size.height),c.helper.width(c.size.width),this._helper&&!l.animate&&this._proportionallyResize()),t("body").css("cursor","auto"),this._removeClass("ui-resizable-resizing"),this._propagate("stop",e),this._helper&&this.helper.remove(),!1},_updatePrevProperties:function(){this.prevPosition={top:this.position.top,left:this.position.left},this.prevSize={width:this.size.width,height:this.size.height}},_applyChanges:function(){var t={};return this.position.top!==this.prevPosition.top&&(t.top=this.position.top+"px"),this.position.left!==this.prevPosition.left&&(t.left=this.position.left+"px"),this.size.width!==this.prevSize.width&&(t.width=this.size.width+"px"),this.size.height!==this.prevSize.height&&(t.height=this.size.height+"px"),this.helper.css(t),t},_updateVirtualBoundaries:function(t){var e,i,s,n,o,a=this.options;o={minWidth:this._isNumber(a.minWidth)?a.minWidth:0,maxWidth:this._isNumber(a.maxWidth)?a.maxWidth:1/0,minHeight:this._isNumber(a.minHeight)?a.minHeight:0,maxHeight:this._isNumber(a.maxHeight)?a.maxHeight:1/0},(this._aspectRatio||t)&&(e=o.minHeight*this.aspectRatio,s=o.minWidth/this.aspectRatio,i=o.maxHeight*this.aspectRatio,n=o.maxWidth/this.aspectRatio,e>o.minWidth&&(o.minWidth=e),s>o.minHeight&&(o.minHeight=s),o.maxWidth>i&&(o.maxWidth=i),o.maxHeight>n&&(o.maxHeight=n)),this._vBoundaries=o},_updateCache:function(t){this.offset=this.helper.offset(),this._isNumber(t.left)&&(this.position.left=t.left),this._isNumber(t.top)&&(this.position.top=t.top),this._isNumber(t.height)&&(this.size.height=t.height),this._isNumber(t.width)&&(this.size.width=t.width)},_updateRatio:function(t){var e=this.position,i=this.size,s=this.axis;return this._isNumber(t.height)?t.width=t.height*this.aspectRatio:this._isNumber(t.width)&&(t.height=t.width/this.aspectRatio),"sw"===s&&(t.left=e.left+(i.width-t.width),t.top=null),"nw"===s&&(t.top=e.top+(i.height-t.height),t.left=e.left+(i.width-t.width)),t},_respectSize:function(t){var e=this._vBoundaries,i=this.axis,s=this._isNumber(t.width)&&e.maxWidth&&e.maxWidth<t.width,n=this._isNumber(t.height)&&e.maxHeight&&e.maxHeight<t.height,o=this._isNumber(t.width)&&e.minWidth&&e.minWidth>t.width,a=this._isNumber(t.height)&&e.minHeight&&e.minHeight>t.height,r=this.originalPosition.left+this.originalSize.width,h=this.originalPosition.top+this.originalSize.height,l=/sw|nw|w/.test(i),c=/nw|ne|n/.test(i);return o&&(t.width=e.minWidth),a&&(t.height=e.minHeight),s&&(t.width=e.maxWidth),n&&(t.height=e.maxHeight),o&&l&&(t.left=r-e.minWidth),s&&l&&(t.left=r-e.maxWidth),a&&c&&(t.top=h-e.minHeight),n&&c&&(t.top=h-e.maxHeight),t.width||t.height||t.left||!t.top?t.width||t.height||t.top||!t.left||(t.left=null):t.top=null,t},_getPaddingPlusBorderDimensions:function(t){for(var e=0,i=[],s=[t.css("borderTopWidth"),t.css("borderRightWidth"),t.css("borderBottomWidth"),t.css("borderLeftWidth")],n=[t.css("paddingTop"),t.css("paddingRight"),t.css("paddingBottom"),t.css("paddingLeft")];4>e;e++)i[e]=parseFloat(s[e])||0,i[e]+=parseFloat(n[e])||0;return{height:i[0]+i[2],width:i[1]+i[3]}},_proportionallyResize:function(){if(this._proportionallyResizeElements.length)for(var t,e=0,i=this.helper||this.element;this._proportionallyResizeElements.length>e;e++)t=this._proportionallyResizeElements[e],this.outerDimensions||(this.outerDimensions=this._getPaddingPlusBorderDimensions(t)),t.css({height:i.height()-this.outerDimensions.height||0,width:i.width()-this.outerDimensions.width||0})},_renderProxy:function(){var e=this.element,i=this.options;this.elementOffset=e.offset(),this._helper?(this.helper=this.helper||t("<div style='overflow:hidden;'></div>"),this._addClass(this.helper,this._helper),this.helper.css({width:this.element.outerWidth(),height:this.element.outerHeight(),position:"absolute",left:this.elementOffset.left+"px",top:this.elementOffset.top+"px",zIndex:++i.zIndex}),this.helper.appendTo("body").disableSelection()):this.helper=this.element
+},_change:{e:function(t,e){return{width:this.originalSize.width+e}},w:function(t,e){var i=this.originalSize,s=this.originalPosition;return{left:s.left+e,width:i.width-e}},n:function(t,e,i){var s=this.originalSize,n=this.originalPosition;return{top:n.top+i,height:s.height-i}},s:function(t,e,i){return{height:this.originalSize.height+i}},se:function(e,i,s){return t.extend(this._change.s.apply(this,arguments),this._change.e.apply(this,[e,i,s]))},sw:function(e,i,s){return t.extend(this._change.s.apply(this,arguments),this._change.w.apply(this,[e,i,s]))},ne:function(e,i,s){return t.extend(this._change.n.apply(this,arguments),this._change.e.apply(this,[e,i,s]))},nw:function(e,i,s){return t.extend(this._change.n.apply(this,arguments),this._change.w.apply(this,[e,i,s]))}},_propagate:function(e,i){t.ui.plugin.call(this,e,[i,this.ui()]),"resize"!==e&&this._trigger(e,i,this.ui())},plugins:{},ui:function(){return{originalElement:this.originalElement,element:this.element,helper:this.helper,position:this.position,size:this.size,originalSize:this.originalSize,originalPosition:this.originalPosition}}}),t.ui.plugin.add("resizable","animate",{stop:function(e){var i=t(this).resizable("instance"),s=i.options,n=i._proportionallyResizeElements,o=n.length&&/textarea/i.test(n[0].nodeName),a=o&&i._hasScroll(n[0],"left")?0:i.sizeDiff.height,r=o?0:i.sizeDiff.width,h={width:i.size.width-r,height:i.size.height-a},l=parseFloat(i.element.css("left"))+(i.position.left-i.originalPosition.left)||null,c=parseFloat(i.element.css("top"))+(i.position.top-i.originalPosition.top)||null;i.element.animate(t.extend(h,c&&l?{top:c,left:l}:{}),{duration:s.animateDuration,easing:s.animateEasing,step:function(){var s={width:parseFloat(i.element.css("width")),height:parseFloat(i.element.css("height")),top:parseFloat(i.element.css("top")),left:parseFloat(i.element.css("left"))};n&&n.length&&t(n[0]).css({width:s.width,height:s.height}),i._updateCache(s),i._propagate("resize",e)}})}}),t.ui.plugin.add("resizable","containment",{start:function(){var e,i,s,n,o,a,r,h=t(this).resizable("instance"),l=h.options,c=h.element,u=l.containment,d=u instanceof t?u.get(0):/parent/.test(u)?c.parent().get(0):u;d&&(h.containerElement=t(d),/document/.test(u)||u===document?(h.containerOffset={left:0,top:0},h.containerPosition={left:0,top:0},h.parentData={element:t(document),left:0,top:0,width:t(document).width(),height:t(document).height()||document.body.parentNode.scrollHeight}):(e=t(d),i=[],t(["Top","Right","Left","Bottom"]).each(function(t,s){i[t]=h._num(e.css("padding"+s))}),h.containerOffset=e.offset(),h.containerPosition=e.position(),h.containerSize={height:e.innerHeight()-i[3],width:e.innerWidth()-i[1]},s=h.containerOffset,n=h.containerSize.height,o=h.containerSize.width,a=h._hasScroll(d,"left")?d.scrollWidth:o,r=h._hasScroll(d)?d.scrollHeight:n,h.parentData={element:d,left:s.left,top:s.top,width:a,height:r}))},resize:function(e){var i,s,n,o,a=t(this).resizable("instance"),r=a.options,h=a.containerOffset,l=a.position,c=a._aspectRatio||e.shiftKey,u={top:0,left:0},d=a.containerElement,p=!0;d[0]!==document&&/static/.test(d.css("position"))&&(u=h),l.left<(a._helper?h.left:0)&&(a.size.width=a.size.width+(a._helper?a.position.left-h.left:a.position.left-u.left),c&&(a.size.height=a.size.width/a.aspectRatio,p=!1),a.position.left=r.helper?h.left:0),l.top<(a._helper?h.top:0)&&(a.size.height=a.size.height+(a._helper?a.position.top-h.top:a.position.top),c&&(a.size.width=a.size.height*a.aspectRatio,p=!1),a.position.top=a._helper?h.top:0),n=a.containerElement.get(0)===a.element.parent().get(0),o=/relative|absolute/.test(a.containerElement.css("position")),n&&o?(a.offset.left=a.parentData.left+a.position.left,a.offset.top=a.parentData.top+a.position.top):(a.offset.left=a.element.offset().left,a.offset.top=a.element.offset().top),i=Math.abs(a.sizeDiff.width+(a._helper?a.offset.left-u.left:a.offset.left-h.left)),s=Math.abs(a.sizeDiff.height+(a._helper?a.offset.top-u.top:a.offset.top-h.top)),i+a.size.width>=a.parentData.width&&(a.size.width=a.parentData.width-i,c&&(a.size.height=a.size.width/a.aspectRatio,p=!1)),s+a.size.height>=a.parentData.height&&(a.size.height=a.parentData.height-s,c&&(a.size.width=a.size.height*a.aspectRatio,p=!1)),p||(a.position.left=a.prevPosition.left,a.position.top=a.prevPosition.top,a.size.width=a.prevSize.width,a.size.height=a.prevSize.height)},stop:function(){var e=t(this).resizable("instance"),i=e.options,s=e.containerOffset,n=e.containerPosition,o=e.containerElement,a=t(e.helper),r=a.offset(),h=a.outerWidth()-e.sizeDiff.width,l=a.outerHeight()-e.sizeDiff.height;e._helper&&!i.animate&&/relative/.test(o.css("position"))&&t(this).css({left:r.left-n.left-s.left,width:h,height:l}),e._helper&&!i.animate&&/static/.test(o.css("position"))&&t(this).css({left:r.left-n.left-s.left,width:h,height:l})}}),t.ui.plugin.add("resizable","alsoResize",{start:function(){var e=t(this).resizable("instance"),i=e.options;t(i.alsoResize).each(function(){var e=t(this);e.data("ui-resizable-alsoresize",{width:parseFloat(e.width()),height:parseFloat(e.height()),left:parseFloat(e.css("left")),top:parseFloat(e.css("top"))})})},resize:function(e,i){var s=t(this).resizable("instance"),n=s.options,o=s.originalSize,a=s.originalPosition,r={height:s.size.height-o.height||0,width:s.size.width-o.width||0,top:s.position.top-a.top||0,left:s.position.left-a.left||0};t(n.alsoResize).each(function(){var e=t(this),s=t(this).data("ui-resizable-alsoresize"),n={},o=e.parents(i.originalElement[0]).length?["width","height"]:["width","height","top","left"];t.each(o,function(t,e){var i=(s[e]||0)+(r[e]||0);i&&i>=0&&(n[e]=i||null)}),e.css(n)})},stop:function(){t(this).removeData("ui-resizable-alsoresize")}}),t.ui.plugin.add("resizable","ghost",{start:function(){var e=t(this).resizable("instance"),i=e.size;e.ghost=e.originalElement.clone(),e.ghost.css({opacity:.25,display:"block",position:"relative",height:i.height,width:i.width,margin:0,left:0,top:0}),e._addClass(e.ghost,"ui-resizable-ghost"),t.uiBackCompat!==!1&&"string"==typeof e.options.ghost&&e.ghost.addClass(this.options.ghost),e.ghost.appendTo(e.helper)},resize:function(){var e=t(this).resizable("instance");e.ghost&&e.ghost.css({position:"relative",height:e.size.height,width:e.size.width})},stop:function(){var e=t(this).resizable("instance");e.ghost&&e.helper&&e.helper.get(0).removeChild(e.ghost.get(0))}}),t.ui.plugin.add("resizable","grid",{resize:function(){var e,i=t(this).resizable("instance"),s=i.options,n=i.size,o=i.originalSize,a=i.originalPosition,r=i.axis,h="number"==typeof s.grid?[s.grid,s.grid]:s.grid,l=h[0]||1,c=h[1]||1,u=Math.round((n.width-o.width)/l)*l,d=Math.round((n.height-o.height)/c)*c,p=o.width+u,f=o.height+d,m=s.maxWidth&&p>s.maxWidth,g=s.maxHeight&&f>s.maxHeight,_=s.minWidth&&s.minWidth>p,v=s.minHeight&&s.minHeight>f;s.grid=h,_&&(p+=l),v&&(f+=c),m&&(p-=l),g&&(f-=c),/^(se|s|e)$/.test(r)?(i.size.width=p,i.size.height=f):/^(ne)$/.test(r)?(i.size.width=p,i.size.height=f,i.position.top=a.top-d):/^(sw)$/.test(r)?(i.size.width=p,i.size.height=f,i.position.left=a.left-u):((0>=f-c||0>=p-l)&&(e=i._getPaddingPlusBorderDimensions(this)),f-c>0?(i.size.height=f,i.position.top=a.top-d):(f=c-e.height,i.size.height=f,i.position.top=a.top+o.height-f),p-l>0?(i.size.width=p,i.position.left=a.left-u):(p=l-e.width,i.size.width=p,i.position.left=a.left+o.width-p))}}),t.ui.resizable});/**
+ * Copyright (c) 2007 Ariel Flesler - aflesler ○ gmail • com | https://github.com/flesler
+ * Licensed under MIT
+ * @author Ariel Flesler
+ * @version 2.1.2
+ */
+;(function(f){"use strict";"function"===typeof define&&define.amd?define(["jquery"],f):"undefined"!==typeof module&&module.exports?module.exports=f(require("jquery")):f(jQuery)})(function($){"use strict";function n(a){return!a.nodeName||-1!==$.inArray(a.nodeName.toLowerCase(),["iframe","#document","html","body"])}function h(a){return $.isFunction(a)||$.isPlainObject(a)?a:{top:a,left:a}}var p=$.scrollTo=function(a,d,b){return $(window).scrollTo(a,d,b)};p.defaults={axis:"xy",duration:0,limit:!0};$.fn.scrollTo=function(a,d,b){"object"=== typeof d&&(b=d,d=0);"function"===typeof b&&(b={onAfter:b});"max"===a&&(a=9E9);b=$.extend({},p.defaults,b);d=d||b.duration;var u=b.queue&&1<b.axis.length;u&&(d/=2);b.offset=h(b.offset);b.over=h(b.over);return this.each(function(){function k(a){var k=$.extend({},b,{queue:!0,duration:d,complete:a&&function(){a.call(q,e,b)}});r.animate(f,k)}if(null!==a){var l=n(this),q=l?this.contentWindow||window:this,r=$(q),e=a,f={},t;switch(typeof e){case "number":case "string":if(/^([+-]=?)?\d+(\.\d+)?(px|%)?$/.test(e)){e= h(e);break}e=l?$(e):$(e,q);case "object":if(e.length===0)return;if(e.is||e.style)t=(e=$(e)).offset()}var v=$.isFunction(b.offset)&&b.offset(q,e)||b.offset;$.each(b.axis.split(""),function(a,c){var d="x"===c?"Left":"Top",m=d.toLowerCase(),g="scroll"+d,h=r[g](),n=p.max(q,c);t?(f[g]=t[m]+(l?0:h-r.offset()[m]),b.margin&&(f[g]-=parseInt(e.css("margin"+d),10)||0,f[g]-=parseInt(e.css("border"+d+"Width"),10)||0),f[g]+=v[m]||0,b.over[m]&&(f[g]+=e["x"===c?"width":"height"]()*b.over[m])):(d=e[m],f[g]=d.slice&& "%"===d.slice(-1)?parseFloat(d)/100*n:d);b.limit&&/^\d+$/.test(f[g])&&(f[g]=0>=f[g]?0:Math.min(f[g],n));!a&&1<b.axis.length&&(h===f[g]?f={}:u&&(k(b.onAfterFirst),f={}))});k(b.onAfter)}})};p.max=function(a,d){var b="x"===d?"Width":"Height",h="scroll"+b;if(!n(a))return a[h]-$(a)[b.toLowerCase()]();var b="client"+b,k=a.ownerDocument||a.document,l=k.documentElement,k=k.body;return Math.max(l[h],k[h])-Math.min(l[b],k[b])};$.Tween.propHooks.scrollLeft=$.Tween.propHooks.scrollTop={get:function(a){return $(a.elem)[a.prop]()}, set:function(a){var d=this.get(a);if(a.options.interrupt&&a._last&&a._last!==d)return $(a.elem).stop();var b=Math.round(a.now);d!==b&&($(a.elem)[a.prop](b),a._last=this.get(a))}};return p});
+/*!
+ PowerTip v1.3.1 (2018-04-15)
+ https://stevenbenner.github.io/jquery-powertip/
+ Copyright (c) 2018 Steven Benner (http://stevenbenner.com/).
+ Released under MIT license.
+ https://raw.github.com/stevenbenner/jquery-powertip/master/LICENSE.txt
+*/
+(function(root,factory){if(typeof define==="function"&&define.amd){define(["jquery"],factory)}else if(typeof module==="object"&&module.exports){module.exports=factory(require("jquery"))}else{factory(root.jQuery)}})(this,function($){var $document=$(document),$window=$(window),$body=$("body");var DATA_DISPLAYCONTROLLER="displayController",DATA_HASACTIVEHOVER="hasActiveHover",DATA_FORCEDOPEN="forcedOpen",DATA_HASMOUSEMOVE="hasMouseMove",DATA_MOUSEONTOTIP="mouseOnToPopup",DATA_ORIGINALTITLE="originalTitle",DATA_POWERTIP="powertip",DATA_POWERTIPJQ="powertipjq",DATA_POWERTIPTARGET="powertiptarget",EVENT_NAMESPACE=".powertip",RAD2DEG=180/Math.PI,MOUSE_EVENTS=["click","dblclick","mousedown","mouseup","mousemove","mouseover","mouseout","mouseenter","mouseleave","contextmenu"];var session={tooltips:null,isTipOpen:false,isFixedTipOpen:false,isClosing:false,tipOpenImminent:false,activeHover:null,currentX:0,currentY:0,previousX:0,previousY:0,desyncTimeout:null,closeDelayTimeout:null,mouseTrackingActive:false,delayInProgress:false,windowWidth:0,windowHeight:0,scrollTop:0,scrollLeft:0};var Collision={none:0,top:1,bottom:2,left:4,right:8};$.fn.powerTip=function(opts,arg){var targetElements=this,options,tipController;if(!targetElements.length){return targetElements}if($.type(opts)==="string"&&$.powerTip[opts]){return $.powerTip[opts].call(targetElements,targetElements,arg)}options=$.extend({},$.fn.powerTip.defaults,opts);tipController=new TooltipController(options);initTracking();targetElements.each(function elementSetup(){var $this=$(this),dataPowertip=$this.data(DATA_POWERTIP),dataElem=$this.data(DATA_POWERTIPJQ),dataTarget=$this.data(DATA_POWERTIPTARGET),title=$this.attr("title");if(!dataPowertip&&!dataTarget&&!dataElem&&title){$this.data(DATA_POWERTIP,title);$this.data(DATA_ORIGINALTITLE,title);$this.removeAttr("title")}$this.data(DATA_DISPLAYCONTROLLER,new DisplayController($this,options,tipController))});if(!options.manual){$.each(options.openEvents,function(idx,evt){if($.inArray(evt,options.closeEvents)>-1){targetElements.on(evt+EVENT_NAMESPACE,function elementToggle(event){$.powerTip.toggle(this,event)})}else{targetElements.on(evt+EVENT_NAMESPACE,function elementOpen(event){$.powerTip.show(this,event)})}});$.each(options.closeEvents,function(idx,evt){if($.inArray(evt,options.openEvents)<0){targetElements.on(evt+EVENT_NAMESPACE,function elementClose(event){$.powerTip.hide(this,!isMouseEvent(event))})}});targetElements.on("keydown"+EVENT_NAMESPACE,function elementKeyDown(event){if(event.keyCode===27){$.powerTip.hide(this,true)}})}return targetElements};$.fn.powerTip.defaults={fadeInTime:200,fadeOutTime:100,followMouse:false,popupId:"powerTip",popupClass:null,intentSensitivity:7,intentPollInterval:100,closeDelay:100,placement:"n",smartPlacement:false,offset:10,mouseOnToPopup:false,manual:false,openEvents:["mouseenter","focus"],closeEvents:["mouseleave","blur"]};$.fn.powerTip.smartPlacementLists={n:["n","ne","nw","s"],e:["e","ne","se","w","nw","sw","n","s","e"],s:["s","se","sw","n"],w:["w","nw","sw","e","ne","se","n","s","w"],nw:["nw","w","sw","n","s","se","nw"],ne:["ne","e","se","n","s","sw","ne"],sw:["sw","w","nw","s","n","ne","sw"],se:["se","e","ne","s","n","nw","se"],"nw-alt":["nw-alt","n","ne-alt","sw-alt","s","se-alt","w","e"],"ne-alt":["ne-alt","n","nw-alt","se-alt","s","sw-alt","e","w"],"sw-alt":["sw-alt","s","se-alt","nw-alt","n","ne-alt","w","e"],"se-alt":["se-alt","s","sw-alt","ne-alt","n","nw-alt","e","w"]};$.powerTip={show:function apiShowTip(element,event){if(isMouseEvent(event)){trackMouse(event);session.previousX=event.pageX;session.previousY=event.pageY;$(element).data(DATA_DISPLAYCONTROLLER).show()}else{$(element).first().data(DATA_DISPLAYCONTROLLER).show(true,true)}return element},reposition:function apiResetPosition(element){$(element).first().data(DATA_DISPLAYCONTROLLER).resetPosition();return element},hide:function apiCloseTip(element,immediate){var displayController;immediate=element?immediate:true;if(element){displayController=$(element).first().data(DATA_DISPLAYCONTROLLER)}else if(session.activeHover){displayController=session.activeHover.data(DATA_DISPLAYCONTROLLER)}if(displayController){displayController.hide(immediate)}return element},toggle:function apiToggle(element,event){if(session.activeHover&&session.activeHover.is(element)){$.powerTip.hide(element,!isMouseEvent(event))}else{$.powerTip.show(element,event)}return element}};$.powerTip.showTip=$.powerTip.show;$.powerTip.closeTip=$.powerTip.hide;function CSSCoordinates(){var me=this;me.top="auto";me.left="auto";me.right="auto";me.bottom="auto";me.set=function(property,value){if($.isNumeric(value)){me[property]=Math.round(value)}}}function DisplayController(element,options,tipController){var hoverTimer=null,myCloseDelay=null;function openTooltip(immediate,forceOpen){cancelTimer();if(!element.data(DATA_HASACTIVEHOVER)){if(!immediate){session.tipOpenImminent=true;hoverTimer=setTimeout(function intentDelay(){hoverTimer=null;checkForIntent()},options.intentPollInterval)}else{if(forceOpen){element.data(DATA_FORCEDOPEN,true)}closeAnyDelayed();tipController.showTip(element)}}else{cancelClose()}}function closeTooltip(disableDelay){if(myCloseDelay){myCloseDelay=session.closeDelayTimeout=clearTimeout(myCloseDelay);session.delayInProgress=false}cancelTimer();session.tipOpenImminent=false;if(element.data(DATA_HASACTIVEHOVER)){element.data(DATA_FORCEDOPEN,false);if(!disableDelay){session.delayInProgress=true;session.closeDelayTimeout=setTimeout(function closeDelay(){session.closeDelayTimeout=null;tipController.hideTip(element);session.delayInProgress=false;myCloseDelay=null},options.closeDelay);myCloseDelay=session.closeDelayTimeout}else{tipController.hideTip(element)}}}function checkForIntent(){var xDifference=Math.abs(session.previousX-session.currentX),yDifference=Math.abs(session.previousY-session.currentY),totalDifference=xDifference+yDifference;if(totalDifference<options.intentSensitivity){cancelClose();closeAnyDelayed();tipController.showTip(element)}else{session.previousX=session.currentX;session.previousY=session.currentY;openTooltip()}}function cancelTimer(stopClose){hoverTimer=clearTimeout(hoverTimer);if(session.closeDelayTimeout&&myCloseDelay===session.closeDelayTimeout||stopClose){cancelClose()}}function cancelClose(){session.closeDelayTimeout=clearTimeout(session.closeDelayTimeout);session.delayInProgress=false}function closeAnyDelayed(){if(session.delayInProgress&&session.activeHover&&!session.activeHover.is(element)){session.activeHover.data(DATA_DISPLAYCONTROLLER).hide(true)}}function repositionTooltip(){tipController.resetPosition(element)}this.show=openTooltip;this.hide=closeTooltip;this.cancel=cancelTimer;this.resetPosition=repositionTooltip}function PlacementCalculator(){function computePlacementCoords(element,placement,tipWidth,tipHeight,offset){var placementBase=placement.split("-")[0],coords=new CSSCoordinates,position;if(isSvgElement(element)){position=getSvgPlacement(element,placementBase)}else{position=getHtmlPlacement(element,placementBase)}switch(placement){case"n":coords.set("left",position.left-tipWidth/2);coords.set("bottom",session.windowHeight-position.top+offset);break;case"e":coords.set("left",position.left+offset);coords.set("top",position.top-tipHeight/2);break;case"s":coords.set("left",position.left-tipWidth/2);coords.set("top",position.top+offset);break;case"w":coords.set("top",position.top-tipHeight/2);coords.set("right",session.windowWidth-position.left+offset);break;case"nw":coords.set("bottom",session.windowHeight-position.top+offset);coords.set("right",session.windowWidth-position.left-20);break;case"nw-alt":coords.set("left",position.left);coords.set("bottom",session.windowHeight-position.top+offset);break;case"ne":coords.set("left",position.left-20);coords.set("bottom",session.windowHeight-position.top+offset);break;case"ne-alt":coords.set("bottom",session.windowHeight-position.top+offset);coords.set("right",session.windowWidth-position.left);break;case"sw":coords.set("top",position.top+offset);coords.set("right",session.windowWidth-position.left-20);break;case"sw-alt":coords.set("left",position.left);coords.set("top",position.top+offset);break;case"se":coords.set("left",position.left-20);coords.set("top",position.top+offset);break;case"se-alt":coords.set("top",position.top+offset);coords.set("right",session.windowWidth-position.left);break}return coords}function getHtmlPlacement(element,placement){var objectOffset=element.offset(),objectWidth=element.outerWidth(),objectHeight=element.outerHeight(),left,top;switch(placement){case"n":left=objectOffset.left+objectWidth/2;top=objectOffset.top;break;case"e":left=objectOffset.left+objectWidth;top=objectOffset.top+objectHeight/2;break;case"s":left=objectOffset.left+objectWidth/2;top=objectOffset.top+objectHeight;break;case"w":left=objectOffset.left;top=objectOffset.top+objectHeight/2;break;case"nw":left=objectOffset.left;top=objectOffset.top;break;case"ne":left=objectOffset.left+objectWidth;top=objectOffset.top;break;case"sw":left=objectOffset.left;top=objectOffset.top+objectHeight;break;case"se":left=objectOffset.left+objectWidth;top=objectOffset.top+objectHeight;break}return{top:top,left:left}}function getSvgPlacement(element,placement){var svgElement=element.closest("svg")[0],domElement=element[0],point=svgElement.createSVGPoint(),boundingBox=domElement.getBBox(),matrix=domElement.getScreenCTM(),halfWidth=boundingBox.width/2,halfHeight=boundingBox.height/2,placements=[],placementKeys=["nw","n","ne","e","se","s","sw","w"],coords,rotation,steps,x;function pushPlacement(){placements.push(point.matrixTransform(matrix))}point.x=boundingBox.x;point.y=boundingBox.y;pushPlacement();point.x+=halfWidth;pushPlacement();point.x+=halfWidth;pushPlacement();point.y+=halfHeight;pushPlacement();point.y+=halfHeight;pushPlacement();point.x-=halfWidth;pushPlacement();point.x-=halfWidth;pushPlacement();point.y-=halfHeight;pushPlacement();if(placements[0].y!==placements[1].y||placements[0].x!==placements[7].x){rotation=Math.atan2(matrix.b,matrix.a)*RAD2DEG;steps=Math.ceil((rotation%360-22.5)/45);if(steps<1){steps+=8}while(steps--){placementKeys.push(placementKeys.shift())}}for(x=0;x<placements.length;x++){if(placementKeys[x]===placement){coords=placements[x];break}}return{top:coords.y+session.scrollTop,left:coords.x+session.scrollLeft}}this.compute=computePlacementCoords}function TooltipController(options){var placementCalculator=new PlacementCalculator,tipElement=$("#"+options.popupId);if(tipElement.length===0){tipElement=$("<div/>",{id:options.popupId});if($body.length===0){$body=$("body")}$body.append(tipElement);session.tooltips=session.tooltips?session.tooltips.add(tipElement):tipElement}if(options.followMouse){if(!tipElement.data(DATA_HASMOUSEMOVE)){$document.on("mousemove"+EVENT_NAMESPACE,positionTipOnCursor);$window.on("scroll"+EVENT_NAMESPACE,positionTipOnCursor);tipElement.data(DATA_HASMOUSEMOVE,true)}}function beginShowTip(element){element.data(DATA_HASACTIVEHOVER,true);tipElement.queue(function queueTipInit(next){showTip(element);next()})}function showTip(element){var tipContent;if(!element.data(DATA_HASACTIVEHOVER)){return}if(session.isTipOpen){if(!session.isClosing){hideTip(session.activeHover)}tipElement.delay(100).queue(function queueTipAgain(next){showTip(element);next()});return}element.trigger("powerTipPreRender");tipContent=getTooltipContent(element);if(tipContent){tipElement.empty().append(tipContent)}else{return}element.trigger("powerTipRender");session.activeHover=element;session.isTipOpen=true;tipElement.data(DATA_MOUSEONTOTIP,options.mouseOnToPopup);tipElement.addClass(options.popupClass);if(!options.followMouse||element.data(DATA_FORCEDOPEN)){positionTipOnElement(element);session.isFixedTipOpen=true}else{positionTipOnCursor()}if(!element.data(DATA_FORCEDOPEN)&&!options.followMouse){$document.on("click"+EVENT_NAMESPACE,function documentClick(event){var target=event.target;if(target!==element[0]){if(options.mouseOnToPopup){if(target!==tipElement[0]&&!$.contains(tipElement[0],target)){$.powerTip.hide()}}else{$.powerTip.hide()}}})}if(options.mouseOnToPopup&&!options.manual){tipElement.on("mouseenter"+EVENT_NAMESPACE,function tipMouseEnter(){if(session.activeHover){session.activeHover.data(DATA_DISPLAYCONTROLLER).cancel()}});tipElement.on("mouseleave"+EVENT_NAMESPACE,function tipMouseLeave(){if(session.activeHover){session.activeHover.data(DATA_DISPLAYCONTROLLER).hide()}})}tipElement.fadeIn(options.fadeInTime,function fadeInCallback(){if(!session.desyncTimeout){session.desyncTimeout=setInterval(closeDesyncedTip,500)}element.trigger("powerTipOpen")})}function hideTip(element){session.isClosing=true;session.isTipOpen=false;session.desyncTimeout=clearInterval(session.desyncTimeout);element.data(DATA_HASACTIVEHOVER,false);element.data(DATA_FORCEDOPEN,false);$document.off("click"+EVENT_NAMESPACE);tipElement.off(EVENT_NAMESPACE);tipElement.fadeOut(options.fadeOutTime,function fadeOutCallback(){var coords=new CSSCoordinates;session.activeHover=null;session.isClosing=false;session.isFixedTipOpen=false;tipElement.removeClass();coords.set("top",session.currentY+options.offset);coords.set("left",session.currentX+options.offset);tipElement.css(coords);element.trigger("powerTipClose")})}function positionTipOnCursor(){var tipWidth,tipHeight,coords,collisions,collisionCount;if(!session.isFixedTipOpen&&(session.isTipOpen||session.tipOpenImminent&&tipElement.data(DATA_HASMOUSEMOVE))){tipWidth=tipElement.outerWidth();tipHeight=tipElement.outerHeight();coords=new CSSCoordinates;coords.set("top",session.currentY+options.offset);coords.set("left",session.currentX+options.offset);collisions=getViewportCollisions(coords,tipWidth,tipHeight);if(collisions!==Collision.none){collisionCount=countFlags(collisions);if(collisionCount===1){if(collisions===Collision.right){coords.set("left",session.scrollLeft+session.windowWidth-tipWidth)}else if(collisions===Collision.bottom){coords.set("top",session.scrollTop+session.windowHeight-tipHeight)}}else{coords.set("left",session.currentX-tipWidth-options.offset);coords.set("top",session.currentY-tipHeight-options.offset)}}tipElement.css(coords)}}function positionTipOnElement(element){var priorityList,finalPlacement;if(options.smartPlacement||options.followMouse&&element.data(DATA_FORCEDOPEN)){priorityList=$.fn.powerTip.smartPlacementLists[options.placement];$.each(priorityList,function(idx,pos){var collisions=getViewportCollisions(placeTooltip(element,pos),tipElement.outerWidth(),tipElement.outerHeight());finalPlacement=pos;return collisions!==Collision.none})}else{placeTooltip(element,options.placement);finalPlacement=options.placement}tipElement.removeClass("w nw sw e ne se n s w se-alt sw-alt ne-alt nw-alt");tipElement.addClass(finalPlacement)}function placeTooltip(element,placement){var iterationCount=0,tipWidth,tipHeight,coords=new CSSCoordinates;coords.set("top",0);coords.set("left",0);tipElement.css(coords);do{tipWidth=tipElement.outerWidth();tipHeight=tipElement.outerHeight();coords=placementCalculator.compute(element,placement,tipWidth,tipHeight,options.offset);tipElement.css(coords)}while(++iterationCount<=5&&(tipWidth!==tipElement.outerWidth()||tipHeight!==tipElement.outerHeight()));return coords}function closeDesyncedTip(){var isDesynced=false,hasDesyncableCloseEvent=$.grep(["mouseleave","mouseout","blur","focusout"],function(eventType){return $.inArray(eventType,options.closeEvents)!==-1}).length>0;if(session.isTipOpen&&!session.isClosing&&!session.delayInProgress&&hasDesyncableCloseEvent){if(session.activeHover.data(DATA_HASACTIVEHOVER)===false||session.activeHover.is(":disabled")){isDesynced=true}else if(!isMouseOver(session.activeHover)&&!session.activeHover.is(":focus")&&!session.activeHover.data(DATA_FORCEDOPEN)){if(tipElement.data(DATA_MOUSEONTOTIP)){if(!isMouseOver(tipElement)){isDesynced=true}}else{isDesynced=true}}if(isDesynced){hideTip(session.activeHover)}}}this.showTip=beginShowTip;this.hideTip=hideTip;this.resetPosition=positionTipOnElement}function isSvgElement(element){return Boolean(window.SVGElement&&element[0]instanceof SVGElement)}function isMouseEvent(event){return Boolean(event&&$.inArray(event.type,MOUSE_EVENTS)>-1&&typeof event.pageX==="number")}function initTracking(){if(!session.mouseTrackingActive){session.mouseTrackingActive=true;getViewportDimensions();$(getViewportDimensions);$document.on("mousemove"+EVENT_NAMESPACE,trackMouse);$window.on("resize"+EVENT_NAMESPACE,trackResize);$window.on("scroll"+EVENT_NAMESPACE,trackScroll)}}function getViewportDimensions(){session.scrollLeft=$window.scrollLeft();session.scrollTop=$window.scrollTop();session.windowWidth=$window.width();session.windowHeight=$window.height()}function trackResize(){session.windowWidth=$window.width();session.windowHeight=$window.height()}function trackScroll(){var x=$window.scrollLeft(),y=$window.scrollTop();if(x!==session.scrollLeft){session.currentX+=x-session.scrollLeft;session.scrollLeft=x}if(y!==session.scrollTop){session.currentY+=y-session.scrollTop;session.scrollTop=y}}function trackMouse(event){session.currentX=event.pageX;session.currentY=event.pageY}function isMouseOver(element){var elementPosition=element.offset(),elementBox=element[0].getBoundingClientRect(),elementWidth=elementBox.right-elementBox.left,elementHeight=elementBox.bottom-elementBox.top;return session.currentX>=elementPosition.left&&session.currentX<=elementPosition.left+elementWidth&&session.currentY>=elementPosition.top&&session.currentY<=elementPosition.top+elementHeight}function getTooltipContent(element){var tipText=element.data(DATA_POWERTIP),tipObject=element.data(DATA_POWERTIPJQ),tipTarget=element.data(DATA_POWERTIPTARGET),targetElement,content;if(tipText){if($.isFunction(tipText)){tipText=tipText.call(element[0])}content=tipText}else if(tipObject){if($.isFunction(tipObject)){tipObject=tipObject.call(element[0])}if(tipObject.length>0){content=tipObject.clone(true,true)}}else if(tipTarget){targetElement=$("#"+tipTarget);if(targetElement.length>0){content=targetElement.html()}}return content}function getViewportCollisions(coords,elementWidth,elementHeight){var viewportTop=session.scrollTop,viewportLeft=session.scrollLeft,viewportBottom=viewportTop+session.windowHeight,viewportRight=viewportLeft+session.windowWidth,collisions=Collision.none;if(coords.top<viewportTop||Math.abs(coords.bottom-session.windowHeight)-elementHeight<viewportTop){collisions|=Collision.top}if(coords.top+elementHeight>viewportBottom||Math.abs(coords.bottom-session.windowHeight)>viewportBottom){collisions|=Collision.bottom}if(coords.left<viewportLeft||coords.right+elementWidth>viewportRight){collisions|=Collision.left}if(coords.left+elementWidth>viewportRight||coords.right<viewportLeft){collisions|=Collision.right}return collisions}function countFlags(value){var count=0;while(value){value&=value-1;count++}return count}return $.powerTip});/*!
+ * jQuery UI Touch Punch 0.2.3
+ *
+ * Copyright 2011–2014, Dave Furfero
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ *
+ * Depends:
+ * jquery.ui.widget.js
+ * jquery.ui.mouse.js
+ */
+!function(a){function f(a,b){if(!(a.originalEvent.touches.length>1)){a.preventDefault();var c=a.originalEvent.changedTouches[0],d=document.createEvent("MouseEvents");d.initMouseEvent(b,!0,!0,window,1,c.screenX,c.screenY,c.clientX,c.clientY,!1,!1,!1,!1,0,null),a.target.dispatchEvent(d)}}if(a.support.touch="ontouchend"in document,a.support.touch){var e,b=a.ui.mouse.prototype,c=b._mouseInit,d=b._mouseDestroy;b._touchStart=function(a){var b=this;!e&&b._mouseCapture(a.originalEvent.changedTouches[0])&&(e=!0,b._touchMoved=!1,f(a,"mouseover"),f(a,"mousemove"),f(a,"mousedown"))},b._touchMove=function(a){e&&(this._touchMoved=!0,f(a,"mousemove"))},b._touchEnd=function(a){e&&(f(a,"mouseup"),f(a,"mouseout"),this._touchMoved||f(a,"click"),e=!1)},b._mouseInit=function(){var b=this;b.element.bind({touchstart:a.proxy(b,"_touchStart"),touchmove:a.proxy(b,"_touchMove"),touchend:a.proxy(b,"_touchEnd")}),c.call(b)},b._mouseDestroy=function(){var b=this;b.element.unbind({touchstart:a.proxy(b,"_touchStart"),touchmove:a.proxy(b,"_touchMove"),touchend:a.proxy(b,"_touchEnd")}),d.call(b)}}}(jQuery);/*! SmartMenus jQuery Plugin - v1.1.0 - September 17, 2017
+ * http://www.smartmenus.org/
+ * Copyright Vasil Dinkov, Vadikom Web Ltd. http://vadikom.com; Licensed MIT */(function(t){"function"==typeof define&&define.amd?define(["jquery"],t):"object"==typeof module&&"object"==typeof module.exports?module.exports=t(require("jquery")):t(jQuery)})(function($){function initMouseDetection(t){var e=".smartmenus_mouse";if(mouseDetectionEnabled||t)mouseDetectionEnabled&&t&&($(document).off(e),mouseDetectionEnabled=!1);else{var i=!0,s=null,o={mousemove:function(t){var e={x:t.pageX,y:t.pageY,timeStamp:(new Date).getTime()};if(s){var o=Math.abs(s.x-e.x),a=Math.abs(s.y-e.y);if((o>0||a>0)&&2>=o&&2>=a&&300>=e.timeStamp-s.timeStamp&&(mouse=!0,i)){var n=$(t.target).closest("a");n.is("a")&&$.each(menuTrees,function(){return $.contains(this.$root[0],n[0])?(this.itemEnter({currentTarget:n[0]}),!1):void 0}),i=!1}}s=e}};o[touchEvents?"touchstart":"pointerover pointermove pointerout MSPointerOver MSPointerMove MSPointerOut"]=function(t){isTouchEvent(t.originalEvent)&&(mouse=!1)},$(document).on(getEventsNS(o,e)),mouseDetectionEnabled=!0}}function isTouchEvent(t){return!/^(4|mouse)$/.test(t.pointerType)}function getEventsNS(t,e){e||(e="");var i={};for(var s in t)i[s.split(" ").join(e+" ")+e]=t[s];return i}var menuTrees=[],mouse=!1,touchEvents="ontouchstart"in window,mouseDetectionEnabled=!1,requestAnimationFrame=window.requestAnimationFrame||function(t){return setTimeout(t,1e3/60)},cancelAnimationFrame=window.cancelAnimationFrame||function(t){clearTimeout(t)},canAnimate=!!$.fn.animate;return $.SmartMenus=function(t,e){this.$root=$(t),this.opts=e,this.rootId="",this.accessIdPrefix="",this.$subArrow=null,this.activatedItems=[],this.visibleSubMenus=[],this.showTimeout=0,this.hideTimeout=0,this.scrollTimeout=0,this.clickActivated=!1,this.focusActivated=!1,this.zIndexInc=0,this.idInc=0,this.$firstLink=null,this.$firstSub=null,this.disabled=!1,this.$disableOverlay=null,this.$touchScrollingSub=null,this.cssTransforms3d="perspective"in t.style||"webkitPerspective"in t.style,this.wasCollapsible=!1,this.init()},$.extend($.SmartMenus,{hideAll:function(){$.each(menuTrees,function(){this.menuHideAll()})},destroy:function(){for(;menuTrees.length;)menuTrees[0].destroy();initMouseDetection(!0)},prototype:{init:function(t){var e=this;if(!t){menuTrees.push(this),this.rootId=((new Date).getTime()+Math.random()+"").replace(/\D/g,""),this.accessIdPrefix="sm-"+this.rootId+"-",this.$root.hasClass("sm-rtl")&&(this.opts.rightToLeftSubMenus=!0);var i=".smartmenus";this.$root.data("smartmenus",this).attr("data-smartmenus-id",this.rootId).dataSM("level",1).on(getEventsNS({"mouseover focusin":$.proxy(this.rootOver,this),"mouseout focusout":$.proxy(this.rootOut,this),keydown:$.proxy(this.rootKeyDown,this)},i)).on(getEventsNS({mouseenter:$.proxy(this.itemEnter,this),mouseleave:$.proxy(this.itemLeave,this),mousedown:$.proxy(this.itemDown,this),focus:$.proxy(this.itemFocus,this),blur:$.proxy(this.itemBlur,this),click:$.proxy(this.itemClick,this)},i),"a"),i+=this.rootId,this.opts.hideOnClick&&$(document).on(getEventsNS({touchstart:$.proxy(this.docTouchStart,this),touchmove:$.proxy(this.docTouchMove,this),touchend:$.proxy(this.docTouchEnd,this),click:$.proxy(this.docClick,this)},i)),$(window).on(getEventsNS({"resize orientationchange":$.proxy(this.winResize,this)},i)),this.opts.subIndicators&&(this.$subArrow=$("<span/>").addClass("sub-arrow"),this.opts.subIndicatorsText&&this.$subArrow.html(this.opts.subIndicatorsText)),initMouseDetection()}if(this.$firstSub=this.$root.find("ul").each(function(){e.menuInit($(this))}).eq(0),this.$firstLink=this.$root.find("a").eq(0),this.opts.markCurrentItem){var s=/(index|default)\.[^#\?\/]*/i,o=/#.*/,a=window.location.href.replace(s,""),n=a.replace(o,"");this.$root.find("a").each(function(){var t=this.href.replace(s,""),i=$(this);(t==a||t==n)&&(i.addClass("current"),e.opts.markCurrentTree&&i.parentsUntil("[data-smartmenus-id]","ul").each(function(){$(this).dataSM("parent-a").addClass("current")}))})}this.wasCollapsible=this.isCollapsible()},destroy:function(t){if(!t){var e=".smartmenus";this.$root.removeData("smartmenus").removeAttr("data-smartmenus-id").removeDataSM("level").off(e),e+=this.rootId,$(document).off(e),$(window).off(e),this.opts.subIndicators&&(this.$subArrow=null)}this.menuHideAll();var i=this;this.$root.find("ul").each(function(){var t=$(this);t.dataSM("scroll-arrows")&&t.dataSM("scroll-arrows").remove(),t.dataSM("shown-before")&&((i.opts.subMenusMinWidth||i.opts.subMenusMaxWidth)&&t.css({width:"",minWidth:"",maxWidth:""}).removeClass("sm-nowrap"),t.dataSM("scroll-arrows")&&t.dataSM("scroll-arrows").remove(),t.css({zIndex:"",top:"",left:"",marginLeft:"",marginTop:"",display:""})),0==(t.attr("id")||"").indexOf(i.accessIdPrefix)&&t.removeAttr("id")}).removeDataSM("in-mega").removeDataSM("shown-before").removeDataSM("scroll-arrows").removeDataSM("parent-a").removeDataSM("level").removeDataSM("beforefirstshowfired").removeAttr("role").removeAttr("aria-hidden").removeAttr("aria-labelledby").removeAttr("aria-expanded"),this.$root.find("a.has-submenu").each(function(){var t=$(this);0==t.attr("id").indexOf(i.accessIdPrefix)&&t.removeAttr("id")}).removeClass("has-submenu").removeDataSM("sub").removeAttr("aria-haspopup").removeAttr("aria-controls").removeAttr("aria-expanded").closest("li").removeDataSM("sub"),this.opts.subIndicators&&this.$root.find("span.sub-arrow").remove(),this.opts.markCurrentItem&&this.$root.find("a.current").removeClass("current"),t||(this.$root=null,this.$firstLink=null,this.$firstSub=null,this.$disableOverlay&&(this.$disableOverlay.remove(),this.$disableOverlay=null),menuTrees.splice($.inArray(this,menuTrees),1))},disable:function(t){if(!this.disabled){if(this.menuHideAll(),!t&&!this.opts.isPopup&&this.$root.is(":visible")){var e=this.$root.offset();this.$disableOverlay=$('<div class="sm-jquery-disable-overlay"/>').css({position:"absolute",top:e.top,left:e.left,width:this.$root.outerWidth(),height:this.$root.outerHeight(),zIndex:this.getStartZIndex(!0),opacity:0}).appendTo(document.body)}this.disabled=!0}},docClick:function(t){return this.$touchScrollingSub?(this.$touchScrollingSub=null,void 0):((this.visibleSubMenus.length&&!$.contains(this.$root[0],t.target)||$(t.target).closest("a").length)&&this.menuHideAll(),void 0)},docTouchEnd:function(){if(this.lastTouch){if(!(!this.visibleSubMenus.length||void 0!==this.lastTouch.x2&&this.lastTouch.x1!=this.lastTouch.x2||void 0!==this.lastTouch.y2&&this.lastTouch.y1!=this.lastTouch.y2||this.lastTouch.target&&$.contains(this.$root[0],this.lastTouch.target))){this.hideTimeout&&(clearTimeout(this.hideTimeout),this.hideTimeout=0);var t=this;this.hideTimeout=setTimeout(function(){t.menuHideAll()},350)}this.lastTouch=null}},docTouchMove:function(t){if(this.lastTouch){var e=t.originalEvent.touches[0];this.lastTouch.x2=e.pageX,this.lastTouch.y2=e.pageY}},docTouchStart:function(t){var e=t.originalEvent.touches[0];this.lastTouch={x1:e.pageX,y1:e.pageY,target:e.target}},enable:function(){this.disabled&&(this.$disableOverlay&&(this.$disableOverlay.remove(),this.$disableOverlay=null),this.disabled=!1)},getClosestMenu:function(t){for(var e=$(t).closest("ul");e.dataSM("in-mega");)e=e.parent().closest("ul");return e[0]||null},getHeight:function(t){return this.getOffset(t,!0)},getOffset:function(t,e){var i;"none"==t.css("display")&&(i={position:t[0].style.position,visibility:t[0].style.visibility},t.css({position:"absolute",visibility:"hidden"}).show());var s=t[0].getBoundingClientRect&&t[0].getBoundingClientRect(),o=s&&(e?s.height||s.bottom-s.top:s.width||s.right-s.left);return o||0===o||(o=e?t[0].offsetHeight:t[0].offsetWidth),i&&t.hide().css(i),o},getStartZIndex:function(t){var e=parseInt(this[t?"$root":"$firstSub"].css("z-index"));return!t&&isNaN(e)&&(e=parseInt(this.$root.css("z-index"))),isNaN(e)?1:e},getTouchPoint:function(t){return t.touches&&t.touches[0]||t.changedTouches&&t.changedTouches[0]||t},getViewport:function(t){var e=t?"Height":"Width",i=document.documentElement["client"+e],s=window["inner"+e];return s&&(i=Math.min(i,s)),i},getViewportHeight:function(){return this.getViewport(!0)},getViewportWidth:function(){return this.getViewport()},getWidth:function(t){return this.getOffset(t)},handleEvents:function(){return!this.disabled&&this.isCSSOn()},handleItemEvents:function(t){return this.handleEvents()&&!this.isLinkInMegaMenu(t)},isCollapsible:function(){return"static"==this.$firstSub.css("position")},isCSSOn:function(){return"inline"!=this.$firstLink.css("display")},isFixed:function(){var t="fixed"==this.$root.css("position");return t||this.$root.parentsUntil("body").each(function(){return"fixed"==$(this).css("position")?(t=!0,!1):void 0}),t},isLinkInMegaMenu:function(t){return $(this.getClosestMenu(t[0])).hasClass("mega-menu")},isTouchMode:function(){return!mouse||this.opts.noMouseOver||this.isCollapsible()},itemActivate:function(t,e){var i=t.closest("ul"),s=i.dataSM("level");if(s>1&&(!this.activatedItems[s-2]||this.activatedItems[s-2][0]!=i.dataSM("parent-a")[0])){var o=this;$(i.parentsUntil("[data-smartmenus-id]","ul").get().reverse()).add(i).each(function(){o.itemActivate($(this).dataSM("parent-a"))})}if((!this.isCollapsible()||e)&&this.menuHideSubMenus(this.activatedItems[s-1]&&this.activatedItems[s-1][0]==t[0]?s:s-1),this.activatedItems[s-1]=t,this.$root.triggerHandler("activate.smapi",t[0])!==!1){var a=t.dataSM("sub");a&&(this.isTouchMode()||!this.opts.showOnClick||this.clickActivated)&&this.menuShow(a)}},itemBlur:function(t){var e=$(t.currentTarget);this.handleItemEvents(e)&&this.$root.triggerHandler("blur.smapi",e[0])},itemClick:function(t){var e=$(t.currentTarget);if(this.handleItemEvents(e)){if(this.$touchScrollingSub&&this.$touchScrollingSub[0]==e.closest("ul")[0])return this.$touchScrollingSub=null,t.stopPropagation(),!1;if(this.$root.triggerHandler("click.smapi",e[0])===!1)return!1;var i=$(t.target).is(".sub-arrow"),s=e.dataSM("sub"),o=s?2==s.dataSM("level"):!1,a=this.isCollapsible(),n=/toggle$/.test(this.opts.collapsibleBehavior),r=/link$/.test(this.opts.collapsibleBehavior),h=/^accordion/.test(this.opts.collapsibleBehavior);if(s&&!s.is(":visible")){if((!r||!a||i)&&(this.opts.showOnClick&&o&&(this.clickActivated=!0),this.itemActivate(e,h),s.is(":visible")))return this.focusActivated=!0,!1}else if(a&&(n||i))return this.itemActivate(e,h),this.menuHide(s),n&&(this.focusActivated=!1),!1;return this.opts.showOnClick&&o||e.hasClass("disabled")||this.$root.triggerHandler("select.smapi",e[0])===!1?!1:void 0}},itemDown:function(t){var e=$(t.currentTarget);this.handleItemEvents(e)&&e.dataSM("mousedown",!0)},itemEnter:function(t){var e=$(t.currentTarget);if(this.handleItemEvents(e)){if(!this.isTouchMode()){this.showTimeout&&(clearTimeout(this.showTimeout),this.showTimeout=0);var i=this;this.showTimeout=setTimeout(function(){i.itemActivate(e)},this.opts.showOnClick&&1==e.closest("ul").dataSM("level")?1:this.opts.showTimeout)}this.$root.triggerHandler("mouseenter.smapi",e[0])}},itemFocus:function(t){var e=$(t.currentTarget);this.handleItemEvents(e)&&(!this.focusActivated||this.isTouchMode()&&e.dataSM("mousedown")||this.activatedItems.length&&this.activatedItems[this.activatedItems.length-1][0]==e[0]||this.itemActivate(e,!0),this.$root.triggerHandler("focus.smapi",e[0]))},itemLeave:function(t){var e=$(t.currentTarget);this.handleItemEvents(e)&&(this.isTouchMode()||(e[0].blur(),this.showTimeout&&(clearTimeout(this.showTimeout),this.showTimeout=0)),e.removeDataSM("mousedown"),this.$root.triggerHandler("mouseleave.smapi",e[0]))},menuHide:function(t){if(this.$root.triggerHandler("beforehide.smapi",t[0])!==!1&&(canAnimate&&t.stop(!0,!0),"none"!=t.css("display"))){var e=function(){t.css("z-index","")};this.isCollapsible()?canAnimate&&this.opts.collapsibleHideFunction?this.opts.collapsibleHideFunction.call(this,t,e):t.hide(this.opts.collapsibleHideDuration,e):canAnimate&&this.opts.hideFunction?this.opts.hideFunction.call(this,t,e):t.hide(this.opts.hideDuration,e),t.dataSM("scroll")&&(this.menuScrollStop(t),t.css({"touch-action":"","-ms-touch-action":"","-webkit-transform":"",transform:""}).off(".smartmenus_scroll").removeDataSM("scroll").dataSM("scroll-arrows").hide()),t.dataSM("parent-a").removeClass("highlighted").attr("aria-expanded","false"),t.attr({"aria-expanded":"false","aria-hidden":"true"});var i=t.dataSM("level");this.activatedItems.splice(i-1,1),this.visibleSubMenus.splice($.inArray(t,this.visibleSubMenus),1),this.$root.triggerHandler("hide.smapi",t[0])}},menuHideAll:function(){this.showTimeout&&(clearTimeout(this.showTimeout),this.showTimeout=0);for(var t=this.opts.isPopup?1:0,e=this.visibleSubMenus.length-1;e>=t;e--)this.menuHide(this.visibleSubMenus[e]);this.opts.isPopup&&(canAnimate&&this.$root.stop(!0,!0),this.$root.is(":visible")&&(canAnimate&&this.opts.hideFunction?this.opts.hideFunction.call(this,this.$root):this.$root.hide(this.opts.hideDuration))),this.activatedItems=[],this.visibleSubMenus=[],this.clickActivated=!1,this.focusActivated=!1,this.zIndexInc=0,this.$root.triggerHandler("hideAll.smapi")},menuHideSubMenus:function(t){for(var e=this.activatedItems.length-1;e>=t;e--){var i=this.activatedItems[e].dataSM("sub");i&&this.menuHide(i)}},menuInit:function(t){if(!t.dataSM("in-mega")){t.hasClass("mega-menu")&&t.find("ul").dataSM("in-mega",!0);for(var e=2,i=t[0];(i=i.parentNode.parentNode)!=this.$root[0];)e++;var s=t.prevAll("a").eq(-1);s.length||(s=t.prevAll().find("a").eq(-1)),s.addClass("has-submenu").dataSM("sub",t),t.dataSM("parent-a",s).dataSM("level",e).parent().dataSM("sub",t);var o=s.attr("id")||this.accessIdPrefix+ ++this.idInc,a=t.attr("id")||this.accessIdPrefix+ ++this.idInc;s.attr({id:o,"aria-haspopup":"true","aria-controls":a,"aria-expanded":"false"}),t.attr({id:a,role:"group","aria-hidden":"true","aria-labelledby":o,"aria-expanded":"false"}),this.opts.subIndicators&&s[this.opts.subIndicatorsPos](this.$subArrow.clone())}},menuPosition:function(t){var e,i,s=t.dataSM("parent-a"),o=s.closest("li"),a=o.parent(),n=t.dataSM("level"),r=this.getWidth(t),h=this.getHeight(t),u=s.offset(),l=u.left,c=u.top,d=this.getWidth(s),m=this.getHeight(s),p=$(window),f=p.scrollLeft(),v=p.scrollTop(),b=this.getViewportWidth(),S=this.getViewportHeight(),g=a.parent().is("[data-sm-horizontal-sub]")||2==n&&!a.hasClass("sm-vertical"),M=this.opts.rightToLeftSubMenus&&!o.is("[data-sm-reverse]")||!this.opts.rightToLeftSubMenus&&o.is("[data-sm-reverse]"),w=2==n?this.opts.mainMenuSubOffsetX:this.opts.subMenusSubOffsetX,T=2==n?this.opts.mainMenuSubOffsetY:this.opts.subMenusSubOffsetY;if(g?(e=M?d-r-w:w,i=this.opts.bottomToTopSubMenus?-h-T:m+T):(e=M?w-r:d-w,i=this.opts.bottomToTopSubMenus?m-T-h:T),this.opts.keepInViewport){var y=l+e,I=c+i;if(M&&f>y?e=g?f-y+e:d-w:!M&&y+r>f+b&&(e=g?f+b-r-y+e:w-r),g||(S>h&&I+h>v+S?i+=v+S-h-I:(h>=S||v>I)&&(i+=v-I)),g&&(I+h>v+S+.49||v>I)||!g&&h>S+.49){var x=this;t.dataSM("scroll-arrows")||t.dataSM("scroll-arrows",$([$('<span class="scroll-up"><span class="scroll-up-arrow"></span></span>')[0],$('<span class="scroll-down"><span class="scroll-down-arrow"></span></span>')[0]]).on({mouseenter:function(){t.dataSM("scroll").up=$(this).hasClass("scroll-up"),x.menuScroll(t)},mouseleave:function(e){x.menuScrollStop(t),x.menuScrollOut(t,e)},"mousewheel DOMMouseScroll":function(t){t.preventDefault()}}).insertAfter(t));var A=".smartmenus_scroll";if(t.dataSM("scroll",{y:this.cssTransforms3d?0:i-m,step:1,itemH:m,subH:h,arrowDownH:this.getHeight(t.dataSM("scroll-arrows").eq(1))}).on(getEventsNS({mouseover:function(e){x.menuScrollOver(t,e)},mouseout:function(e){x.menuScrollOut(t,e)},"mousewheel DOMMouseScroll":function(e){x.menuScrollMousewheel(t,e)}},A)).dataSM("scroll-arrows").css({top:"auto",left:"0",marginLeft:e+(parseInt(t.css("border-left-width"))||0),width:r-(parseInt(t.css("border-left-width"))||0)-(parseInt(t.css("border-right-width"))||0),zIndex:t.css("z-index")}).eq(g&&this.opts.bottomToTopSubMenus?0:1).show(),this.isFixed()){var C={};C[touchEvents?"touchstart touchmove touchend":"pointerdown pointermove pointerup MSPointerDown MSPointerMove MSPointerUp"]=function(e){x.menuScrollTouch(t,e)},t.css({"touch-action":"none","-ms-touch-action":"none"}).on(getEventsNS(C,A))}}}t.css({top:"auto",left:"0",marginLeft:e,marginTop:i-m})},menuScroll:function(t,e,i){var s,o=t.dataSM("scroll"),a=t.dataSM("scroll-arrows"),n=o.up?o.upEnd:o.downEnd;if(!e&&o.momentum){if(o.momentum*=.92,s=o.momentum,.5>s)return this.menuScrollStop(t),void 0}else s=i||(e||!this.opts.scrollAccelerate?this.opts.scrollStep:Math.floor(o.step));var r=t.dataSM("level");if(this.activatedItems[r-1]&&this.activatedItems[r-1].dataSM("sub")&&this.activatedItems[r-1].dataSM("sub").is(":visible")&&this.menuHideSubMenus(r-1),o.y=o.up&&o.y>=n||!o.up&&n>=o.y?o.y:Math.abs(n-o.y)>s?o.y+(o.up?s:-s):n,t.css(this.cssTransforms3d?{"-webkit-transform":"translate3d(0, "+o.y+"px, 0)",transform:"translate3d(0, "+o.y+"px, 0)"}:{marginTop:o.y}),mouse&&(o.up&&o.y>o.downEnd||!o.up&&o.y<o.upEnd)&&a.eq(o.up?1:0).show(),o.y==n)mouse&&a.eq(o.up?0:1).hide(),this.menuScrollStop(t);else if(!e){this.opts.scrollAccelerate&&o.step<this.opts.scrollStep&&(o.step+=.2);var h=this;this.scrollTimeout=requestAnimationFrame(function(){h.menuScroll(t)})}},menuScrollMousewheel:function(t,e){if(this.getClosestMenu(e.target)==t[0]){e=e.originalEvent;var i=(e.wheelDelta||-e.detail)>0;t.dataSM("scroll-arrows").eq(i?0:1).is(":visible")&&(t.dataSM("scroll").up=i,this.menuScroll(t,!0))}e.preventDefault()},menuScrollOut:function(t,e){mouse&&(/^scroll-(up|down)/.test((e.relatedTarget||"").className)||(t[0]==e.relatedTarget||$.contains(t[0],e.relatedTarget))&&this.getClosestMenu(e.relatedTarget)==t[0]||t.dataSM("scroll-arrows").css("visibility","hidden"))},menuScrollOver:function(t,e){if(mouse&&!/^scroll-(up|down)/.test(e.target.className)&&this.getClosestMenu(e.target)==t[0]){this.menuScrollRefreshData(t);var i=t.dataSM("scroll"),s=$(window).scrollTop()-t.dataSM("parent-a").offset().top-i.itemH;t.dataSM("scroll-arrows").eq(0).css("margin-top",s).end().eq(1).css("margin-top",s+this.getViewportHeight()-i.arrowDownH).end().css("visibility","visible")}},menuScrollRefreshData:function(t){var e=t.dataSM("scroll"),i=$(window).scrollTop()-t.dataSM("parent-a").offset().top-e.itemH;this.cssTransforms3d&&(i=-(parseFloat(t.css("margin-top"))-i)),$.extend(e,{upEnd:i,downEnd:i+this.getViewportHeight()-e.subH})},menuScrollStop:function(t){return this.scrollTimeout?(cancelAnimationFrame(this.scrollTimeout),this.scrollTimeout=0,t.dataSM("scroll").step=1,!0):void 0},menuScrollTouch:function(t,e){if(e=e.originalEvent,isTouchEvent(e)){var i=this.getTouchPoint(e);if(this.getClosestMenu(i.target)==t[0]){var s=t.dataSM("scroll");if(/(start|down)$/i.test(e.type))this.menuScrollStop(t)?(e.preventDefault(),this.$touchScrollingSub=t):this.$touchScrollingSub=null,this.menuScrollRefreshData(t),$.extend(s,{touchStartY:i.pageY,touchStartTime:e.timeStamp});else if(/move$/i.test(e.type)){var o=void 0!==s.touchY?s.touchY:s.touchStartY;if(void 0!==o&&o!=i.pageY){this.$touchScrollingSub=t;var a=i.pageY>o;void 0!==s.up&&s.up!=a&&$.extend(s,{touchStartY:i.pageY,touchStartTime:e.timeStamp}),$.extend(s,{up:a,touchY:i.pageY}),this.menuScroll(t,!0,Math.abs(i.pageY-o))}e.preventDefault()}else void 0!==s.touchY&&((s.momentum=15*Math.pow(Math.abs(i.pageY-s.touchStartY)/(e.timeStamp-s.touchStartTime),2))&&(this.menuScrollStop(t),this.menuScroll(t),e.preventDefault()),delete s.touchY)}}},menuShow:function(t){if((t.dataSM("beforefirstshowfired")||(t.dataSM("beforefirstshowfired",!0),this.$root.triggerHandler("beforefirstshow.smapi",t[0])!==!1))&&this.$root.triggerHandler("beforeshow.smapi",t[0])!==!1&&(t.dataSM("shown-before",!0),canAnimate&&t.stop(!0,!0),!t.is(":visible"))){var e=t.dataSM("parent-a"),i=this.isCollapsible();if((this.opts.keepHighlighted||i)&&e.addClass("highlighted"),i)t.removeClass("sm-nowrap").css({zIndex:"",width:"auto",minWidth:"",maxWidth:"",top:"",left:"",marginLeft:"",marginTop:""});else{if(t.css("z-index",this.zIndexInc=(this.zIndexInc||this.getStartZIndex())+1),(this.opts.subMenusMinWidth||this.opts.subMenusMaxWidth)&&(t.css({width:"auto",minWidth:"",maxWidth:""}).addClass("sm-nowrap"),this.opts.subMenusMinWidth&&t.css("min-width",this.opts.subMenusMinWidth),this.opts.subMenusMaxWidth)){var s=this.getWidth(t);t.css("max-width",this.opts.subMenusMaxWidth),s>this.getWidth(t)&&t.removeClass("sm-nowrap").css("width",this.opts.subMenusMaxWidth)}this.menuPosition(t)}var o=function(){t.css("overflow","")};i?canAnimate&&this.opts.collapsibleShowFunction?this.opts.collapsibleShowFunction.call(this,t,o):t.show(this.opts.collapsibleShowDuration,o):canAnimate&&this.opts.showFunction?this.opts.showFunction.call(this,t,o):t.show(this.opts.showDuration,o),e.attr("aria-expanded","true"),t.attr({"aria-expanded":"true","aria-hidden":"false"}),this.visibleSubMenus.push(t),this.$root.triggerHandler("show.smapi",t[0])}},popupHide:function(t){this.hideTimeout&&(clearTimeout(this.hideTimeout),this.hideTimeout=0);var e=this;this.hideTimeout=setTimeout(function(){e.menuHideAll()},t?1:this.opts.hideTimeout)},popupShow:function(t,e){if(!this.opts.isPopup)return alert('SmartMenus jQuery Error:\n\nIf you want to show this menu via the "popupShow" method, set the isPopup:true option.'),void 0;if(this.hideTimeout&&(clearTimeout(this.hideTimeout),this.hideTimeout=0),this.$root.dataSM("shown-before",!0),canAnimate&&this.$root.stop(!0,!0),!this.$root.is(":visible")){this.$root.css({left:t,top:e});var i=this,s=function(){i.$root.css("overflow","")};canAnimate&&this.opts.showFunction?this.opts.showFunction.call(this,this.$root,s):this.$root.show(this.opts.showDuration,s),this.visibleSubMenus[0]=this.$root}},refresh:function(){this.destroy(!0),this.init(!0)},rootKeyDown:function(t){if(this.handleEvents())switch(t.keyCode){case 27:var e=this.activatedItems[0];if(e){this.menuHideAll(),e[0].focus();var i=e.dataSM("sub");i&&this.menuHide(i)}break;case 32:var s=$(t.target);if(s.is("a")&&this.handleItemEvents(s)){var i=s.dataSM("sub");i&&!i.is(":visible")&&(this.itemClick({currentTarget:t.target}),t.preventDefault())}}},rootOut:function(t){if(this.handleEvents()&&!this.isTouchMode()&&t.target!=this.$root[0]&&(this.hideTimeout&&(clearTimeout(this.hideTimeout),this.hideTimeout=0),!this.opts.showOnClick||!this.opts.hideOnClick)){var e=this;this.hideTimeout=setTimeout(function(){e.menuHideAll()},this.opts.hideTimeout)}},rootOver:function(t){this.handleEvents()&&!this.isTouchMode()&&t.target!=this.$root[0]&&this.hideTimeout&&(clearTimeout(this.hideTimeout),this.hideTimeout=0)},winResize:function(t){if(this.handleEvents()){if(!("onorientationchange"in window)||"orientationchange"==t.type){var e=this.isCollapsible();this.wasCollapsible&&e||(this.activatedItems.length&&this.activatedItems[this.activatedItems.length-1][0].blur(),this.menuHideAll()),this.wasCollapsible=e}}else if(this.$disableOverlay){var i=this.$root.offset();this.$disableOverlay.css({top:i.top,left:i.left,width:this.$root.outerWidth(),height:this.$root.outerHeight()})}}}}),$.fn.dataSM=function(t,e){return e?this.data(t+"_smartmenus",e):this.data(t+"_smartmenus")},$.fn.removeDataSM=function(t){return this.removeData(t+"_smartmenus")},$.fn.smartmenus=function(options){if("string"==typeof options){var args=arguments,method=options;return Array.prototype.shift.call(args),this.each(function(){var t=$(this).data("smartmenus");t&&t[method]&&t[method].apply(t,args)})}return this.each(function(){var dataOpts=$(this).data("sm-options")||null;if(dataOpts)try{dataOpts=eval("("+dataOpts+")")}catch(e){dataOpts=null,alert('ERROR\n\nSmartMenus jQuery init:\nInvalid "data-sm-options" attribute value syntax.')}new $.SmartMenus(this,$.extend({},$.fn.smartmenus.defaults,options,dataOpts))})},$.fn.smartmenus.defaults={isPopup:!1,mainMenuSubOffsetX:0,mainMenuSubOffsetY:0,subMenusSubOffsetX:0,subMenusSubOffsetY:0,subMenusMinWidth:"10em",subMenusMaxWidth:"20em",subIndicators:!0,subIndicatorsPos:"append",subIndicatorsText:"",scrollStep:30,scrollAccelerate:!0,showTimeout:250,hideTimeout:500,showDuration:0,showFunction:null,hideDuration:0,hideFunction:function(t,e){t.fadeOut(200,e)},collapsibleShowDuration:0,collapsibleShowFunction:function(t,e){t.slideDown(200,e)},collapsibleHideDuration:0,collapsibleHideFunction:function(t,e){t.slideUp(200,e)},showOnClick:!1,hideOnClick:!0,noMouseOver:!1,keepInViewport:!0,keepHighlighted:!0,markCurrentItem:!1,markCurrentTree:!0,rightToLeftSubMenus:!1,bottomToTopSubMenus:!1,collapsibleBehavior:"default"},$});
\ No newline at end of file
--- /dev/null
+/*
+ @licstart The following is the entire license notice for the JavaScript code in this file.
+
+ The MIT License (MIT)
+
+ Copyright (C) 1997-2020 by Dimitri van Heesch
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+ and associated documentation files (the "Software"), to deal in the Software without restriction,
+ including without limitation the rights to use, copy, modify, merge, publish, distribute,
+ sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all copies or
+ substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+ @licend The above is the entire license notice for the JavaScript code in this file
+ */
+function initMenu(relPath,searchEnabled,serverSide,searchPage,search) {
+ function makeTree(data,relPath) {
+ var result='';
+ if ('children' in data) {
+ result+='<ul>';
+ for (var i in data.children) {
+ result+='<li><a href="'+relPath+data.children[i].url+'">'+
+ data.children[i].text+'</a>'+
+ makeTree(data.children[i],relPath)+'</li>';
+ }
+ result+='</ul>';
+ }
+ return result;
+ }
+
+ $('#main-nav').append(makeTree(menudata,relPath));
+ $('#main-nav').children(':first').addClass('sm sm-dox').attr('id','main-menu');
+ if (searchEnabled) {
+ if (serverSide) {
+ $('#main-menu').append('<li style="float:right"><div id="MSearchBox" class="MSearchBoxInactive"><div class="left"><form id="FSearchBox" action="'+relPath+searchPage+'" method="get"><img id="MSearchSelect" src="'+relPath+'search/mag.svg" alt=""/><input type="text" id="MSearchField" name="query" value="'+search+'" size="20" accesskey="S" onfocus="searchBox.OnSearchFieldFocus(true)" onblur="searchBox.OnSearchFieldFocus(false)"></form></div><div class="right"></div></div></li>');
+ } else {
+ $('#main-menu').append('<li style="float:right"><div id="MSearchBox" class="MSearchBoxInactive"><span class="left"><img id="MSearchSelect" src="'+relPath+'search/mag_sel.svg" onmouseover="return searchBox.OnSearchSelectShow()" onmouseout="return searchBox.OnSearchSelectHide()" alt=""/><input type="text" id="MSearchField" value="'+search+'" accesskey="S" onfocus="searchBox.OnSearchFieldFocus(true)" onblur="searchBox.OnSearchFieldFocus(false)" onkeyup="searchBox.OnSearchFieldChange(event)"/></span><span class="right"><a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="'+relPath+'search/close.svg" alt=""/></a></span></div></li>');
+ }
+ }
+ $('#main-menu').smartmenus();
+}
+/* @license-end */
--- /dev/null
+/*
+ @licstart The following is the entire license notice for the JavaScript code in this file.
+
+ The MIT License (MIT)
+
+ Copyright (C) 1997-2020 by Dimitri van Heesch
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+ and associated documentation files (the "Software"), to deal in the Software without restriction,
+ including without limitation the rights to use, copy, modify, merge, publish, distribute,
+ sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all copies or
+ substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+ @licend The above is the entire license notice for the JavaScript code in this file
+*/
+var menudata={children:[
+{text:"Main Page",url:"index.html"},
+{text:"Related Pages",url:"pages.html"},
+{text:"Modules",url:"modules.html"},
+{text:"Namespaces",url:"namespaces.html",children:[
+{text:"Namespace List",url:"namespaces.html"},
+{text:"Namespace Members",url:"namespacemembers.html",children:[
+{text:"All",url:"namespacemembers.html",children:[
+{text:"b",url:"namespacemembers.html#index_b"},
+{text:"c",url:"namespacemembers_c.html#index_c"},
+{text:"d",url:"namespacemembers_d.html#index_d"},
+{text:"e",url:"namespacemembers_e.html#index_e"},
+{text:"h",url:"namespacemembers_h.html#index_h"},
+{text:"m",url:"namespacemembers_m.html#index_m"},
+{text:"p",url:"namespacemembers_p.html#index_p"},
+{text:"r",url:"namespacemembers_r.html#index_r"},
+{text:"t",url:"namespacemembers_t.html#index_t"},
+{text:"u",url:"namespacemembers_u.html#index_u"},
+{text:"v",url:"namespacemembers_v.html#index_v"}]},
+{text:"Functions",url:"namespacemembers_func.html",children:[
+{text:"b",url:"namespacemembers_func.html#index_b"},
+{text:"c",url:"namespacemembers_func_c.html#index_c"},
+{text:"e",url:"namespacemembers_func_e.html#index_e"},
+{text:"h",url:"namespacemembers_func_h.html#index_h"},
+{text:"m",url:"namespacemembers_func_m.html#index_m"},
+{text:"p",url:"namespacemembers_func_p.html#index_p"},
+{text:"r",url:"namespacemembers_func_r.html#index_r"},
+{text:"t",url:"namespacemembers_func_t.html#index_t"},
+{text:"u",url:"namespacemembers_func_u.html#index_u"},
+{text:"v",url:"namespacemembers_func_v.html#index_v"}]},
+{text:"Typedefs",url:"namespacemembers_type.html"}]}]},
+{text:"Classes",url:"annotated.html",children:[
+{text:"Class List",url:"annotated.html"},
+{text:"Class Index",url:"classes.html"},
+{text:"Class Hierarchy",url:"inherits.html"},
+{text:"Class Members",url:"functions.html",children:[
+{text:"All",url:"functions.html",children:[
+{text:"a",url:"functions.html#index_a"},
+{text:"b",url:"functions_b.html#index_b"},
+{text:"c",url:"functions_c.html#index_c"},
+{text:"d",url:"functions_d.html#index_d"},
+{text:"e",url:"functions_e.html#index_e"},
+{text:"f",url:"functions_f.html#index_f"},
+{text:"g",url:"functions_g.html#index_g"},
+{text:"h",url:"functions_h.html#index_h"},
+{text:"i",url:"functions_i.html#index_i"},
+{text:"l",url:"functions_l.html#index_l"},
+{text:"m",url:"functions_m.html#index_m"},
+{text:"n",url:"functions_n.html#index_n"},
+{text:"o",url:"functions_o.html#index_o"},
+{text:"p",url:"functions_p.html#index_p"},
+{text:"r",url:"functions_r.html#index_r"},
+{text:"s",url:"functions_s.html#index_s"},
+{text:"t",url:"functions_t.html#index_t"},
+{text:"u",url:"functions_u.html#index_u"},
+{text:"v",url:"functions_v.html#index_v"},
+{text:"~",url:"functions_~.html#index__7E"}]},
+{text:"Functions",url:"functions_func.html",children:[
+{text:"a",url:"functions_func.html#index_a"},
+{text:"b",url:"functions_func_b.html#index_b"},
+{text:"c",url:"functions_func_c.html#index_c"},
+{text:"d",url:"functions_func_d.html#index_d"},
+{text:"e",url:"functions_func_e.html#index_e"},
+{text:"f",url:"functions_func_f.html#index_f"},
+{text:"h",url:"functions_func_h.html#index_h"},
+{text:"i",url:"functions_func_i.html#index_i"},
+{text:"l",url:"functions_func_l.html#index_l"},
+{text:"m",url:"functions_func_m.html#index_m"},
+{text:"n",url:"functions_func_n.html#index_n"},
+{text:"o",url:"functions_func_o.html#index_o"},
+{text:"p",url:"functions_func_p.html#index_p"},
+{text:"r",url:"functions_func_r.html#index_r"},
+{text:"s",url:"functions_func_s.html#index_s"},
+{text:"t",url:"functions_func_t.html#index_t"},
+{text:"u",url:"functions_func_u.html#index_u"},
+{text:"v",url:"functions_func_v.html#index_v"},
+{text:"~",url:"functions_func_~.html#index__7E"}]},
+{text:"Variables",url:"functions_vars.html",children:[
+{text:"b",url:"functions_vars.html#index_b"},
+{text:"c",url:"functions_vars.html#index_c"},
+{text:"f",url:"functions_vars.html#index_f"},
+{text:"g",url:"functions_vars.html#index_g"},
+{text:"i",url:"functions_vars.html#index_i"},
+{text:"l",url:"functions_vars.html#index_l"},
+{text:"o",url:"functions_vars.html#index_o"},
+{text:"r",url:"functions_vars.html#index_r"},
+{text:"v",url:"functions_vars.html#index_v"}]},
+{text:"Typedefs",url:"functions_type.html",children:[
+{text:"a",url:"functions_type.html#index_a"},
+{text:"c",url:"functions_type_c.html#index_c"},
+{text:"d",url:"functions_type_d.html#index_d"},
+{text:"e",url:"functions_type_e.html#index_e"},
+{text:"f",url:"functions_type_f.html#index_f"},
+{text:"g",url:"functions_type_g.html#index_g"},
+{text:"i",url:"functions_type_i.html#index_i"},
+{text:"p",url:"functions_type_p.html#index_p"},
+{text:"r",url:"functions_type_r.html#index_r"},
+{text:"s",url:"functions_type_s.html#index_s"},
+{text:"t",url:"functions_type_t.html#index_t"},
+{text:"v",url:"functions_type_v.html#index_v"}]}]}]}]}
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Modules</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">Modules</div> </div>
+</div><!--header-->
+<div class="contents">
+<div class="textblock">Here is a list of all modules:</div><div class="directory">
+<div class="levels">[detail level <span onclick="javascript:toggleLevel(1);">1</span><span onclick="javascript:toggleLevel(2);">2</span>]</div><table class="directory">
+<tr id="row_0_" class="even"><td class="entry"><span style="width:0px;display:inline-block;"> </span><span id="arr_0_" class="arrow" onclick="toggleFolder('0_')">▼</span><a class="el" href="group__adaptors.html" target="_self">Adaptors</a></td><td class="desc">Adaptors are functors that alter the signature of a functor's operator()() </td></tr>
+<tr id="row_0_0_"><td class="entry"><span style="width:32px;display:inline-block;"> </span><a class="el" href="group__bind.html" target="_self">bind(), bind_return()</a></td><td class="desc"><a class="el" href="group__bind.html#ga962b581ef0c17562bb3317783d3ffe7d" title="Creates an adaptor of type sigc::bind_functor which fixes the last 7 argument(s) of the passed functo...">Sigc::bind()</a> alters an arbitrary functor by fixing arguments to certain values </td></tr>
+<tr id="row_0_1_" class="even"><td class="entry"><span style="width:32px;display:inline-block;"> </span><a class="el" href="group__compose.html" target="_self">compose()</a></td><td class="desc"><a class="el" href="group__compose.html#ga4abf2a45eb2307a3dc5d870c86b0450d" title="Creates an adaptor of type sigc::compose2_functor which combines three functors.">Sigc::compose()</a> combines two or three arbitrary functors </td></tr>
+<tr id="row_0_2_"><td class="entry"><span style="width:32px;display:inline-block;"> </span><a class="el" href="group__exception__catch.html" target="_self">exception_catch()</a></td><td class="desc">Sigc::exception_catch() catches an exception thrown from within the wrapped functor and directs it to a catcher functor </td></tr>
+<tr id="row_0_3_" class="even"><td class="entry"><span style="width:32px;display:inline-block;"> </span><a class="el" href="group__hide.html" target="_self">hide(), hide_return()</a></td><td class="desc"><a class="el" href="group__hide.html#gacbbacd3553268d85b95e3a85aefb67e5" title="Creates an adaptor of type sigc::hide_functor which adds a dummy parameter to the passed functor.">Sigc::hide()</a> alters an arbitrary functor in that it adds a parameter whose value is ignored on invocation of the returned functor </td></tr>
+<tr id="row_0_4_"><td class="entry"><span style="width:32px;display:inline-block;"> </span><a class="el" href="group__retype.html" target="_self">retype(), retype_return()</a></td><td class="desc"><a class="el" href="group__retype.html#ga1ec0f19b59050f8f01c8969835b3c742" title="Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed...">Sigc::retype()</a> alters a sigc::pointer_functor, a sigc::mem_functor or a <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> in that it makes C-style casts to the functor's parameter types of all parameters passed through operator()() </td></tr>
+<tr id="row_0_5_" class="even"><td class="entry"><span style="width:32px;display:inline-block;"> </span><a class="el" href="group__track__obj.html" target="_self">track_obj()</a></td><td class="desc"><a class="el" href="group__track__obj.html#ga5ea3e9f52643d7ab1bcfa4f419e7d38f" title="Creates an adaptor of type sigc::track_obj_functor7 which wraps a functor.">Sigc::track_obj()</a> tracks trackable objects, referenced from a functor </td></tr>
+<tr id="row_1_"><td class="entry"><span style="width:0px;display:inline-block;"> </span><span id="arr_1_" class="arrow" onclick="toggleFolder('1_')">▼</span><a class="el" href="group__sigcfunctors.html" target="_self">Functors</a></td><td class="desc">Functors are copyable types that define operator()() </td></tr>
+<tr id="row_1_0_" class="even"><td class="entry"><span style="width:32px;display:inline-block;"> </span><a class="el" href="group__slot.html" target="_self">Slots</a></td><td class="desc">Slots are type-safe representations of callback methods and functions </td></tr>
+<tr id="row_1_1_"><td class="entry"><span style="width:32px;display:inline-block;"> </span><a class="el" href="group__mem__fun.html" target="_self">mem_fun()</a></td><td class="desc">Mem_fun() Creates a functor from a pointer to a method </td></tr>
+<tr id="row_1_2_" class="even"><td class="entry"><span style="width:32px;display:inline-block;"> </span><a class="el" href="group__ptr__fun.html" target="_self">ptr_fun()</a></td><td class="desc">Ptr_fun() is used to convert a pointer to a function to a functor </td></tr>
+<tr id="row_2_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><a class="el" href="group__signal.html" target="_self">Signals</a></td><td class="desc">Use <a class="el" href="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2" title="Add a slot to the list of slots.">sigc::signal::connect()</a> with <a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" title="Creates a functor of type sigc::mem_functor0 which wraps a method.">sigc::mem_fun()</a> and <a class="el" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863" title="Creates a functor of type sigc::pointer_functor0 which wraps an existing non-member function.">sigc::ptr_fun()</a> to connect a method or function with a signal </td></tr>
+</table>
+</div><!-- directory -->
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Namespace Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all namespace members with links to the namespace documentation for each member:</div>
+
+<h3><a id="index_b"></a>- b -</h3><ul>
+<li>bind()
+: <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4">sigc</a>
+</li>
+<li>bind_return()
+: <a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a">sigc</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Namespace Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all namespace members with links to the namespace documentation for each member:</div>
+
+<h3><a id="index_c"></a>- c -</h3><ul>
+<li>compose()
+: <a class="el" href="group__compose.html#ga34cf5da8f6323bfdc41bc7113d6ad20a">sigc</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Namespace Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all namespace members with links to the namespace documentation for each member:</div>
+
+<h3><a id="index_d"></a>- d -</h3><ul>
+<li>deduce_result_t
+: <a class="el" href="namespacesigc.html#ab7791439fb79592300826fe076a8e3d1">sigc</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Namespace Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all namespace members with links to the namespace documentation for each member:</div>
+
+<h3><a id="index_e"></a>- e -</h3><ul>
+<li>exception_catch()
+: <a class="el" href="namespacesigc.html#a0ae3b8a1ba26920cee4d7d9df2c39ed9">sigc</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Namespace Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_b"></a>- b -</h3><ul>
+<li>bind()
+: <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4">sigc</a>
+</li>
+<li>bind_return()
+: <a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a">sigc</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Namespace Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_c"></a>- c -</h3><ul>
+<li>compose()
+: <a class="el" href="group__compose.html#ga34cf5da8f6323bfdc41bc7113d6ad20a">sigc</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Namespace Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_e"></a>- e -</h3><ul>
+<li>exception_catch()
+: <a class="el" href="namespacesigc.html#a0ae3b8a1ba26920cee4d7d9df2c39ed9">sigc</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Namespace Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_h"></a>- h -</h3><ul>
+<li>hide()
+: <a class="el" href="group__hide.html#gaf2cefea3a99acd44f68121424103172d">sigc</a>
+</li>
+<li>hide_return()
+: <a class="el" href="group__hide.html#gae4e6f5491471c12440f1c5d480726b98">sigc</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Namespace Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_m"></a>- m -</h3><ul>
+<li>mem_fun()
+: <a class="el" href="namespacesigc.html#ga3e3841c4844715d2f2d832ed506f028f">sigc</a>
+</li>
+<li>mem_fun0()
+: <a class="el" href="group__mem__fun.html#ga765b35689a909fbc2a627be8256c5b1f">sigc</a>
+</li>
+<li>mem_fun1()
+: <a class="el" href="namespacesigc.html#ga3dd8d2ed97310dbf4fa394999f0be7b7">sigc</a>
+</li>
+<li>mem_fun2()
+: <a class="el" href="namespacesigc.html#ga184da4166c8b5409dc4b98d7bc16dff8">sigc</a>
+</li>
+<li>mem_fun3()
+: <a class="el" href="namespacesigc.html#ga4f2fdbf02e8cac9492326a4a8ffdd012">sigc</a>
+</li>
+<li>mem_fun4()
+: <a class="el" href="namespacesigc.html#ga1bedd04f76ad3e21f614912562e95d83">sigc</a>
+</li>
+<li>mem_fun5()
+: <a class="el" href="namespacesigc.html#gaf060fe3a2be4ff7c0f50aef54b4dc8bf">sigc</a>
+</li>
+<li>mem_fun6()
+: <a class="el" href="namespacesigc.html#ga34ace98fbbd18cb635795639d0f22678">sigc</a>
+</li>
+<li>mem_fun7()
+: <a class="el" href="namespacesigc.html#ga1f704e475da2aad1717e059c264c1436">sigc</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Namespace Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_p"></a>- p -</h3><ul>
+<li>ptr_fun()
+: <a class="el" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863">sigc</a>
+</li>
+<li>ptr_fun0()
+: <a class="el" href="group__ptr__fun.html#gaad8dffc194a4e4dfa0935ce49d43cd5c">sigc</a>
+</li>
+<li>ptr_fun1()
+: <a class="el" href="group__ptr__fun.html#ga9b1b8e8f5555d6be4ba41be3fb82c94e">sigc</a>
+</li>
+<li>ptr_fun2()
+: <a class="el" href="group__ptr__fun.html#ga0244165b83e41a30b2dfb9523afad446">sigc</a>
+</li>
+<li>ptr_fun3()
+: <a class="el" href="group__ptr__fun.html#ga749e83ea85926d5ad6994d775f98de8d">sigc</a>
+</li>
+<li>ptr_fun4()
+: <a class="el" href="group__ptr__fun.html#gac6fa01189c786e778d943a2ee60896a4">sigc</a>
+</li>
+<li>ptr_fun5()
+: <a class="el" href="group__ptr__fun.html#ga37ae059caefef68e441d3dd7d5b11cce">sigc</a>
+</li>
+<li>ptr_fun6()
+: <a class="el" href="group__ptr__fun.html#ga8cdf17b7ec15b260f5147e1171dd5299">sigc</a>
+</li>
+<li>ptr_fun7()
+: <a class="el" href="group__ptr__fun.html#ga82e53ab558dae814c16a09edb53617bb">sigc</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Namespace Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_r"></a>- r -</h3><ul>
+<li>ref()
+: <a class="el" href="namespacesigc.html#a670882bd3fa5890b464871ac515aaba9">sigc</a>
+</li>
+<li>retype()
+: <a class="el" href="group__retype.html#gad916eb17d984df3b7da9b7d3d041168a">sigc</a>
+</li>
+<li>retype_return()
+: <a class="el" href="group__retype.html#ga23a8cdbc12c57fbef0866b5c51d71588">sigc</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Namespace Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_t"></a>- t -</h3><ul>
+<li>track_obj()
+: <a class="el" href="group__track__obj.html#ga8fd1ab36d123ff83dd4cd8dc58bb28e2">sigc</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Namespace Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_u"></a>- u -</h3><ul>
+<li>unwrap()
+: <a class="el" href="namespacesigc.html#a3b5529822bdaf60f07456633e0f40282">sigc</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Namespace Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ 
+
+<h3><a id="index_v"></a>- v -</h3><ul>
+<li>visit_each()
+: <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404">sigc</a>
+</li>
+<li>visit_each_type()
+: <a class="el" href="group__sigcfunctors.html#gada222d975b87d64cfa7a7f29244ae587">sigc</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Namespace Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all namespace members with links to the namespace documentation for each member:</div>
+
+<h3><a id="index_h"></a>- h -</h3><ul>
+<li>hide()
+: <a class="el" href="group__hide.html#gaf2cefea3a99acd44f68121424103172d">sigc</a>
+</li>
+<li>hide_return()
+: <a class="el" href="group__hide.html#gae4e6f5491471c12440f1c5d480726b98">sigc</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Namespace Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all namespace members with links to the namespace documentation for each member:</div>
+
+<h3><a id="index_m"></a>- m -</h3><ul>
+<li>mem_fun()
+: <a class="el" href="namespacesigc.html#ga3e3841c4844715d2f2d832ed506f028f">sigc</a>
+</li>
+<li>mem_fun0()
+: <a class="el" href="group__mem__fun.html#ga765b35689a909fbc2a627be8256c5b1f">sigc</a>
+</li>
+<li>mem_fun1()
+: <a class="el" href="namespacesigc.html#ga3dd8d2ed97310dbf4fa394999f0be7b7">sigc</a>
+</li>
+<li>mem_fun2()
+: <a class="el" href="namespacesigc.html#ga184da4166c8b5409dc4b98d7bc16dff8">sigc</a>
+</li>
+<li>mem_fun3()
+: <a class="el" href="namespacesigc.html#ga4f2fdbf02e8cac9492326a4a8ffdd012">sigc</a>
+</li>
+<li>mem_fun4()
+: <a class="el" href="namespacesigc.html#ga1bedd04f76ad3e21f614912562e95d83">sigc</a>
+</li>
+<li>mem_fun5()
+: <a class="el" href="namespacesigc.html#gaf060fe3a2be4ff7c0f50aef54b4dc8bf">sigc</a>
+</li>
+<li>mem_fun6()
+: <a class="el" href="namespacesigc.html#ga34ace98fbbd18cb635795639d0f22678">sigc</a>
+</li>
+<li>mem_fun7()
+: <a class="el" href="namespacesigc.html#ga1f704e475da2aad1717e059c264c1436">sigc</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Namespace Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all namespace members with links to the namespace documentation for each member:</div>
+
+<h3><a id="index_p"></a>- p -</h3><ul>
+<li>ptr_fun()
+: <a class="el" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863">sigc</a>
+</li>
+<li>ptr_fun0()
+: <a class="el" href="group__ptr__fun.html#gaad8dffc194a4e4dfa0935ce49d43cd5c">sigc</a>
+</li>
+<li>ptr_fun1()
+: <a class="el" href="group__ptr__fun.html#ga9b1b8e8f5555d6be4ba41be3fb82c94e">sigc</a>
+</li>
+<li>ptr_fun2()
+: <a class="el" href="group__ptr__fun.html#ga0244165b83e41a30b2dfb9523afad446">sigc</a>
+</li>
+<li>ptr_fun3()
+: <a class="el" href="group__ptr__fun.html#ga749e83ea85926d5ad6994d775f98de8d">sigc</a>
+</li>
+<li>ptr_fun4()
+: <a class="el" href="group__ptr__fun.html#gac6fa01189c786e778d943a2ee60896a4">sigc</a>
+</li>
+<li>ptr_fun5()
+: <a class="el" href="group__ptr__fun.html#ga37ae059caefef68e441d3dd7d5b11cce">sigc</a>
+</li>
+<li>ptr_fun6()
+: <a class="el" href="group__ptr__fun.html#ga8cdf17b7ec15b260f5147e1171dd5299">sigc</a>
+</li>
+<li>ptr_fun7()
+: <a class="el" href="group__ptr__fun.html#ga82e53ab558dae814c16a09edb53617bb">sigc</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Namespace Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all namespace members with links to the namespace documentation for each member:</div>
+
+<h3><a id="index_r"></a>- r -</h3><ul>
+<li>ref()
+: <a class="el" href="namespacesigc.html#a670882bd3fa5890b464871ac515aaba9">sigc</a>
+</li>
+<li>retype()
+: <a class="el" href="group__retype.html#gad916eb17d984df3b7da9b7d3d041168a">sigc</a>
+</li>
+<li>retype_return()
+: <a class="el" href="group__retype.html#ga23a8cdbc12c57fbef0866b5c51d71588">sigc</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Namespace Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all namespace members with links to the namespace documentation for each member:</div>
+
+<h3><a id="index_t"></a>- t -</h3><ul>
+<li>track_obj()
+: <a class="el" href="group__track__obj.html#ga8fd1ab36d123ff83dd4cd8dc58bb28e2">sigc</a>
+</li>
+<li>type_trait_pass_t
+: <a class="el" href="namespacesigc.html#aa2d13c7fc829cfec6e0f9d5092f2aa79">sigc</a>
+</li>
+<li>type_trait_take_t
+: <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">sigc</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Namespace Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+ <ul>
+<li>deduce_result_t
+: <a class="el" href="namespacesigc.html#ab7791439fb79592300826fe076a8e3d1">sigc</a>
+</li>
+<li>type_trait_pass_t
+: <a class="el" href="namespacesigc.html#aa2d13c7fc829cfec6e0f9d5092f2aa79">sigc</a>
+</li>
+<li>type_trait_take_t
+: <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">sigc</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Namespace Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all namespace members with links to the namespace documentation for each member:</div>
+
+<h3><a id="index_u"></a>- u -</h3><ul>
+<li>unwrap()
+: <a class="el" href="namespacesigc.html#a3b5529822bdaf60f07456633e0f40282">sigc</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Namespace Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all namespace members with links to the namespace documentation for each member:</div>
+
+<h3><a id="index_v"></a>- v -</h3><ul>
+<li>visit_each()
+: <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404">sigc</a>
+</li>
+<li>visit_each_type()
+: <a class="el" href="group__sigcfunctors.html#gada222d975b87d64cfa7a7f29244ae587">sigc</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:41:00 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Namespace List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">Namespace List</div> </div>
+</div><!--header-->
+<div class="contents">
+<div class="textblock">Here is a list of all namespaces with brief descriptions:</div><div class="directory">
+<div class="levels">[detail level <span onclick="javascript:toggleLevel(1);">1</span><span onclick="javascript:toggleLevel(2);">2</span><span onclick="javascript:toggleLevel(3);">3</span>]</div><table class="directory">
+<tr id="row_0_" class="even"><td class="entry"><span style="width:0px;display:inline-block;"> </span><span id="arr_0_" class="arrow" onclick="toggleFolder('0_')">►</span><span class="icona"><span class="icon">N</span></span><a class="el" href="namespacesigc.html" target="_self">sigc</a></td><td class="desc">The libsigc++ namespace </td></tr>
+<tr id="row_0_0_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1adaptor__base.html" target="_self">adaptor_base</a></td><td class="desc">A hint to the compiler </td></tr>
+<tr id="row_0_1_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1adaptor__functor.html" target="_self">adaptor_functor</a></td><td class="desc">Converts an arbitrary functor into an adaptor type </td></tr>
+<tr id="row_0_2_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1adaptor__trait.html" target="_self">adaptor_trait</a></td><td class="desc">Trait that specifies what is the adaptor version of a functor type </td></tr>
+<tr id="row_0_3_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html" target="_self">adaptor_trait< T_functor, false ></a></td><td class="desc">Trait that specifies what is the adaptor version of a functor type </td></tr>
+<tr id="row_0_4_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html" target="_self">adaptor_trait< T_functor, true ></a></td><td class="desc">Trait that specifies what is the adaptor version of a functor type </td></tr>
+<tr id="row_0_5_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1adapts.html" target="_self">adapts</a></td><td class="desc">Base type for adaptors </td></tr>
+<tr id="row_0_6_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1bind__functor.html" target="_self">bind_functor</a></td><td class="desc">Adaptor that binds an argument to the wrapped functor </td></tr>
+<tr id="row_0_7_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a></td><td class="desc">Adaptor that binds an argument to the wrapped functor </td></tr>
+<tr id="row_0_8_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a></td><td class="desc">Adaptor that binds 1 argument(s) to the wrapped functor </td></tr>
+<tr id="row_0_9_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1bind__return__functor.html" target="_self">bind_return_functor</a></td><td class="desc">Adaptor that fixes the return value of the wrapped functor </td></tr>
+<tr id="row_0_10_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__argument.html" target="_self">bound_argument</a></td><td class="desc">A bound_argument<Foo> object stores a bound (for instance, with <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">sigc::bind()</a>, or <a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a" title="Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed funct...">sigc::bind_return()</a>) argument </td></tr>
+<tr id="row_0_11_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html" target="_self">bound_argument< const_reference_wrapper< T_wrapped > ></a></td><td class="desc">Bound_argument object for a bound argument that is passed by <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">bind()</a> or returned by <a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a" title="Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed funct...">bind_return()</a> by const reference, specialized for const reference_wrapper<> types </td></tr>
+<tr id="row_0_12_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html" target="_self">bound_argument< reference_wrapper< T_wrapped > ></a></td><td class="desc">Bound_argument object for a bound argument that is passed by <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">bind()</a> or returned by <a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a" title="Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed funct...">bind_return()</a> by reference, specialized for reference_wrapper<> types </td></tr>
+<tr id="row_0_13_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html" target="_self">bound_argument< std::reference_wrapper< T_wrapped > ></a></td><td class="desc">Bound_argument object for a bound argument that is passed by <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">bind()</a> or returned by <a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a" title="Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed funct...">bind_return()</a> by reference, specialized for std::reference_wrapper<> types </td></tr>
+<tr id="row_0_14_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__mem__functor0.html" target="_self">bound_const_mem_functor0</a></td><td class="desc">Bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance </td></tr>
+<tr id="row_0_15_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__mem__functor1.html" target="_self">bound_const_mem_functor1</a></td><td class="desc">Bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance </td></tr>
+<tr id="row_0_16_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__mem__functor2.html" target="_self">bound_const_mem_functor2</a></td><td class="desc">Bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance </td></tr>
+<tr id="row_0_17_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__mem__functor3.html" target="_self">bound_const_mem_functor3</a></td><td class="desc">Bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance </td></tr>
+<tr id="row_0_18_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__mem__functor4.html" target="_self">bound_const_mem_functor4</a></td><td class="desc">Bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance </td></tr>
+<tr id="row_0_19_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__mem__functor5.html" target="_self">bound_const_mem_functor5</a></td><td class="desc">Bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance </td></tr>
+<tr id="row_0_20_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__mem__functor6.html" target="_self">bound_const_mem_functor6</a></td><td class="desc">Bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance </td></tr>
+<tr id="row_0_21_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__mem__functor7.html" target="_self">bound_const_mem_functor7</a></td><td class="desc">Bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance </td></tr>
+<tr id="row_0_22_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html" target="_self">bound_const_volatile_mem_functor0</a></td><td class="desc">Bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object instance </td></tr>
+<tr id="row_0_23_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html" target="_self">bound_const_volatile_mem_functor1</a></td><td class="desc">Bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object instance </td></tr>
+<tr id="row_0_24_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html" target="_self">bound_const_volatile_mem_functor2</a></td><td class="desc">Bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object instance </td></tr>
+<tr id="row_0_25_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html" target="_self">bound_const_volatile_mem_functor3</a></td><td class="desc">Bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object instance </td></tr>
+<tr id="row_0_26_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html" target="_self">bound_const_volatile_mem_functor4</a></td><td class="desc">Bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object instance </td></tr>
+<tr id="row_0_27_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html" target="_self">bound_const_volatile_mem_functor5</a></td><td class="desc">Bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object instance </td></tr>
+<tr id="row_0_28_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html" target="_self">bound_const_volatile_mem_functor6</a></td><td class="desc">Bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object instance </td></tr>
+<tr id="row_0_29_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html" target="_self">bound_const_volatile_mem_functor7</a></td><td class="desc">Bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object instance </td></tr>
+<tr id="row_0_30_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__mem__functor0.html" target="_self">bound_mem_functor0</a></td><td class="desc">Bound_mem_functor0 encapsulates a method with 0 arguments and an object instance </td></tr>
+<tr id="row_0_31_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__mem__functor1.html" target="_self">bound_mem_functor1</a></td><td class="desc">Bound_mem_functor1 encapsulates a method with 1 arguments and an object instance </td></tr>
+<tr id="row_0_32_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__mem__functor2.html" target="_self">bound_mem_functor2</a></td><td class="desc">Bound_mem_functor2 encapsulates a method with 2 arguments and an object instance </td></tr>
+<tr id="row_0_33_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__mem__functor3.html" target="_self">bound_mem_functor3</a></td><td class="desc">Bound_mem_functor3 encapsulates a method with 3 arguments and an object instance </td></tr>
+<tr id="row_0_34_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__mem__functor4.html" target="_self">bound_mem_functor4</a></td><td class="desc">Bound_mem_functor4 encapsulates a method with 4 arguments and an object instance </td></tr>
+<tr id="row_0_35_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__mem__functor5.html" target="_self">bound_mem_functor5</a></td><td class="desc">Bound_mem_functor5 encapsulates a method with 5 arguments and an object instance </td></tr>
+<tr id="row_0_36_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__mem__functor6.html" target="_self">bound_mem_functor6</a></td><td class="desc">Bound_mem_functor6 encapsulates a method with 6 arguments and an object instance </td></tr>
+<tr id="row_0_37_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__mem__functor7.html" target="_self">bound_mem_functor7</a></td><td class="desc">Bound_mem_functor7 encapsulates a method with 7 arguments and an object instance </td></tr>
+<tr id="row_0_38_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html" target="_self">bound_volatile_mem_functor0</a></td><td class="desc">Bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance </td></tr>
+<tr id="row_0_39_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html" target="_self">bound_volatile_mem_functor1</a></td><td class="desc">Bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance </td></tr>
+<tr id="row_0_40_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html" target="_self">bound_volatile_mem_functor2</a></td><td class="desc">Bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance </td></tr>
+<tr id="row_0_41_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html" target="_self">bound_volatile_mem_functor3</a></td><td class="desc">Bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance </td></tr>
+<tr id="row_0_42_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html" target="_self">bound_volatile_mem_functor4</a></td><td class="desc">Bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance </td></tr>
+<tr id="row_0_43_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html" target="_self">bound_volatile_mem_functor5</a></td><td class="desc">Bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance </td></tr>
+<tr id="row_0_44_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html" target="_self">bound_volatile_mem_functor6</a></td><td class="desc">Bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance </td></tr>
+<tr id="row_0_45_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html" target="_self">bound_volatile_mem_functor7</a></td><td class="desc">Bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance </td></tr>
+<tr id="row_0_46_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1can__deduce__result__type__with__decltype.html" target="_self">can_deduce_result_type_with_decltype</a></td><td class="desc">Helper class, to determine if decltype() can deduce the result type of a functor </td></tr>
+<tr id="row_0_47_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1compose1__functor.html" target="_self">compose1_functor</a></td><td class="desc">Adaptor that combines two functors </td></tr>
+<tr id="row_0_48_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1compose2__functor.html" target="_self">compose2_functor</a></td><td class="desc">Adaptor that combines three functors </td></tr>
+<tr id="row_0_49_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1connection.html" target="_self">connection</a></td><td class="desc">Convinience class for safe disconnection </td></tr>
+<tr id="row_0_50_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__limit__reference.html" target="_self">const_limit_reference</a></td><td class="desc">A const_limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>, then <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each<>()</a> will "limit" itself to the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference instead of the derived reference </td></tr>
+<tr id="row_0_51_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html" target="_self">const_limit_reference< T_type, true ></a></td><td class="desc">Const_limit_reference object for a class that derives from trackable </td></tr>
+<tr id="row_0_52_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__mem__functor0.html" target="_self">const_mem_functor0</a></td><td class="desc">Const_mem_functor0 wraps const methods with 0 argument(s) </td></tr>
+<tr id="row_0_53_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__mem__functor1.html" target="_self">const_mem_functor1</a></td><td class="desc">Const_mem_functor1 wraps const methods with 1 argument(s) </td></tr>
+<tr id="row_0_54_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__mem__functor2.html" target="_self">const_mem_functor2</a></td><td class="desc">Const_mem_functor2 wraps const methods with 2 argument(s) </td></tr>
+<tr id="row_0_55_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__mem__functor3.html" target="_self">const_mem_functor3</a></td><td class="desc">Const_mem_functor3 wraps const methods with 3 argument(s) </td></tr>
+<tr id="row_0_56_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__mem__functor4.html" target="_self">const_mem_functor4</a></td><td class="desc">Const_mem_functor4 wraps const methods with 4 argument(s) </td></tr>
+<tr id="row_0_57_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__mem__functor5.html" target="_self">const_mem_functor5</a></td><td class="desc">Const_mem_functor5 wraps const methods with 5 argument(s) </td></tr>
+<tr id="row_0_58_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__mem__functor6.html" target="_self">const_mem_functor6</a></td><td class="desc">Const_mem_functor6 wraps const methods with 6 argument(s) </td></tr>
+<tr id="row_0_59_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__mem__functor7.html" target="_self">const_mem_functor7</a></td><td class="desc">Const_mem_functor7 wraps const methods with 7 argument(s) </td></tr>
+<tr id="row_0_60_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1const__reference__wrapper.html" target="_self">const_reference_wrapper</a></td><td class="desc">Const reference wrapper </td></tr>
+<tr id="row_0_61_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__limit__reference.html" target="_self">const_volatile_limit_reference</a></td><td class="desc">A const_volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>, then <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each<>()</a> will "limit" itself to the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference instead of the derived reference </td></tr>
+<tr id="row_0_62_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html" target="_self">const_volatile_limit_reference< T_type, true ></a></td><td class="desc">Const_volatile_limit_reference object for a class that derives from trackable </td></tr>
+<tr id="row_0_63_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html" target="_self">const_volatile_mem_functor0</a></td><td class="desc">Const_volatile_mem_functor0 wraps const volatile methods with 0 argument(s) </td></tr>
+<tr id="row_0_64_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html" target="_self">const_volatile_mem_functor1</a></td><td class="desc">Const_volatile_mem_functor1 wraps const volatile methods with 1 argument(s) </td></tr>
+<tr id="row_0_65_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html" target="_self">const_volatile_mem_functor2</a></td><td class="desc">Const_volatile_mem_functor2 wraps const volatile methods with 2 argument(s) </td></tr>
+<tr id="row_0_66_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html" target="_self">const_volatile_mem_functor3</a></td><td class="desc">Const_volatile_mem_functor3 wraps const volatile methods with 3 argument(s) </td></tr>
+<tr id="row_0_67_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html" target="_self">const_volatile_mem_functor4</a></td><td class="desc">Const_volatile_mem_functor4 wraps const volatile methods with 4 argument(s) </td></tr>
+<tr id="row_0_68_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html" target="_self">const_volatile_mem_functor5</a></td><td class="desc">Const_volatile_mem_functor5 wraps const volatile methods with 5 argument(s) </td></tr>
+<tr id="row_0_69_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html" target="_self">const_volatile_mem_functor6</a></td><td class="desc">Const_volatile_mem_functor6 wraps const volatile methods with 6 argument(s) </td></tr>
+<tr id="row_0_70_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html" target="_self">const_volatile_mem_functor7</a></td><td class="desc">Const_volatile_mem_functor7 wraps const volatile methods with 7 argument(s) </td></tr>
+<tr id="row_0_71_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1deduce__result__type.html" target="_self">deduce_result_type</a></td><td class="desc">Deduce the return type of a functor </td></tr>
+<tr id="row_0_72_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1exception__catch__functor.html" target="_self">exception_catch_functor</a></td><td class="desc"></td></tr>
+<tr id="row_0_73_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html" target="_self">exception_catch_functor< T_functor, T_catcher, void ></a></td><td class="desc"></td></tr>
+<tr id="row_0_74_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1functor__base.html" target="_self">functor_base</a></td><td class="desc">A hint to the compiler </td></tr>
+<tr id="row_0_75_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1functor__trait.html" target="_self">functor_trait</a></td><td class="desc">Trait that specifies the return type of any type </td></tr>
+<tr id="row_0_76_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1hide__functor.html" target="_self">hide_functor</a></td><td class="desc">Adaptor that adds a dummy parameter to the wrapped functor </td></tr>
+<tr id="row_0_77_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html" target="_self">hide_functor< 0, T_functor ></a></td><td class="desc">Adaptor that adds a dummy parameter to the wrapped functor </td></tr>
+<tr id="row_0_78_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html" target="_self">hide_functor<-1, T_functor ></a></td><td class="desc">Adaptor that adds a dummy parameter to the wrapped functor </td></tr>
+<tr id="row_0_79_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1limit__reference.html" target="_self">limit_reference</a></td><td class="desc">A limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>, then <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each<>()</a> will "limit" itself to the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference instead of the derived reference </td></tr>
+<tr id="row_0_80_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html" target="_self">limit_reference< T_type, true ></a></td><td class="desc">Limit_reference object for a class that derives from trackable </td></tr>
+<tr id="row_0_81_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1mem__functor0.html" target="_self">mem_functor0</a></td><td class="desc">Mem_functor0 wraps methods with 0 argument(s) </td></tr>
+<tr id="row_0_82_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1mem__functor1.html" target="_self">mem_functor1</a></td><td class="desc">Mem_functor1 wraps methods with 1 argument(s) </td></tr>
+<tr id="row_0_83_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1mem__functor2.html" target="_self">mem_functor2</a></td><td class="desc">Mem_functor2 wraps methods with 2 argument(s) </td></tr>
+<tr id="row_0_84_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1mem__functor3.html" target="_self">mem_functor3</a></td><td class="desc">Mem_functor3 wraps methods with 3 argument(s) </td></tr>
+<tr id="row_0_85_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1mem__functor4.html" target="_self">mem_functor4</a></td><td class="desc">Mem_functor4 wraps methods with 4 argument(s) </td></tr>
+<tr id="row_0_86_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1mem__functor5.html" target="_self">mem_functor5</a></td><td class="desc">Mem_functor5 wraps methods with 5 argument(s) </td></tr>
+<tr id="row_0_87_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1mem__functor6.html" target="_self">mem_functor6</a></td><td class="desc">Mem_functor6 wraps methods with 6 argument(s) </td></tr>
+<tr id="row_0_88_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1mem__functor7.html" target="_self">mem_functor7</a></td><td class="desc">Mem_functor7 wraps methods with 7 argument(s) </td></tr>
+<tr id="row_0_89_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1nil.html" target="_self">nil</a></td><td class="desc">Nil struct type </td></tr>
+<tr id="row_0_90_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1pointer__functor0.html" target="_self">pointer_functor0</a></td><td class="desc">Pointer_functor0 wraps existing non-member functions with 0 argument(s) </td></tr>
+<tr id="row_0_91_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1pointer__functor1.html" target="_self">pointer_functor1</a></td><td class="desc">Pointer_functor1 wraps existing non-member functions with 1 argument(s) </td></tr>
+<tr id="row_0_92_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1pointer__functor2.html" target="_self">pointer_functor2</a></td><td class="desc">Pointer_functor2 wraps existing non-member functions with 2 argument(s) </td></tr>
+<tr id="row_0_93_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1pointer__functor3.html" target="_self">pointer_functor3</a></td><td class="desc">Pointer_functor3 wraps existing non-member functions with 3 argument(s) </td></tr>
+<tr id="row_0_94_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1pointer__functor4.html" target="_self">pointer_functor4</a></td><td class="desc">Pointer_functor4 wraps existing non-member functions with 4 argument(s) </td></tr>
+<tr id="row_0_95_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1pointer__functor5.html" target="_self">pointer_functor5</a></td><td class="desc">Pointer_functor5 wraps existing non-member functions with 5 argument(s) </td></tr>
+<tr id="row_0_96_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1pointer__functor6.html" target="_self">pointer_functor6</a></td><td class="desc">Pointer_functor6 wraps existing non-member functions with 6 argument(s) </td></tr>
+<tr id="row_0_97_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1pointer__functor7.html" target="_self">pointer_functor7</a></td><td class="desc">Pointer_functor7 wraps existing non-member functions with 7 argument(s) </td></tr>
+<tr id="row_0_98_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1reference__wrapper.html" target="_self">reference_wrapper</a></td><td class="desc">Reference wrapper </td></tr>
+<tr id="row_0_99_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1retype__functor.html" target="_self">retype_functor</a></td><td class="desc">Adaptor that performs C-style casts on the parameters passed on to the functor </td></tr>
+<tr id="row_0_100_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1retype__return__functor.html" target="_self">retype_return_functor</a></td><td class="desc">Adaptor that performs a C-style cast on the return value of a functor </td></tr>
+<tr id="row_0_101_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html" target="_self">retype_return_functor< void, T_functor ></a></td><td class="desc">Adaptor that performs a C-style cast on the return value of a functor </td></tr>
+<tr id="row_0_102_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_102_" class="arrow" onclick="toggleFolder('0_102_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal.html" target="_self">signal</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates </td></tr>
+<tr id="row_0_102_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_1_1accumulated.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates </td></tr>
+<tr id="row_0_103_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal0.html" target="_self">signal0</a></td><td class="desc">Signal declaration </td></tr>
+<tr id="row_0_104_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal1.html" target="_self">signal1</a></td><td class="desc">Signal declaration </td></tr>
+<tr id="row_0_105_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal2.html" target="_self">signal2</a></td><td class="desc">Signal declaration </td></tr>
+<tr id="row_0_106_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal3.html" target="_self">signal3</a></td><td class="desc">Signal declaration </td></tr>
+<tr id="row_0_107_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal4.html" target="_self">signal4</a></td><td class="desc">Signal declaration </td></tr>
+<tr id="row_0_108_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal5.html" target="_self">signal5</a></td><td class="desc">Signal declaration </td></tr>
+<tr id="row_0_109_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal6.html" target="_self">signal6</a></td><td class="desc">Signal declaration </td></tr>
+<tr id="row_0_110_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal7.html" target="_self">signal7</a></td><td class="desc">Signal declaration </td></tr>
+<tr id="row_0_111_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_111_" class="arrow" onclick="toggleFolder('0_111_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4.html" target="_self">signal< T_return()></a></td><td class="desc">This specialization allow use of the sigc::signal<R(Args...)> syntax, </td></tr>
+<tr id="row_0_111_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal0.html" title="Signal declaration.">sigc::signal0</a> template </td></tr>
+<tr id="row_0_112_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_112_" class="arrow" onclick="toggleFolder('0_112_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html" target="_self">signal< T_return(T_arg1)></a></td><td class="desc">This specialization allow use of the sigc::signal<R(Args...)> syntax, </td></tr>
+<tr id="row_0_112_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal1.html" title="Signal declaration.">sigc::signal1</a> template </td></tr>
+<tr id="row_0_113_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_113_" class="arrow" onclick="toggleFolder('0_113_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html" target="_self">signal< T_return(T_arg1, T_arg2)></a></td><td class="desc">This specialization allow use of the sigc::signal<R(Args...)> syntax, </td></tr>
+<tr id="row_0_113_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal2.html" title="Signal declaration.">sigc::signal2</a> template </td></tr>
+<tr id="row_0_114_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_114_" class="arrow" onclick="toggleFolder('0_114_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html" target="_self">signal< T_return(T_arg1, T_arg2, T_arg3)></a></td><td class="desc">This specialization allow use of the sigc::signal<R(Args...)> syntax, </td></tr>
+<tr id="row_0_114_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal3.html" title="Signal declaration.">sigc::signal3</a> template </td></tr>
+<tr id="row_0_115_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_115_" class="arrow" onclick="toggleFolder('0_115_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html" target="_self">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)></a></td><td class="desc">This specialization allow use of the sigc::signal<R(Args...)> syntax, </td></tr>
+<tr id="row_0_115_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal4.html" title="Signal declaration.">sigc::signal4</a> template </td></tr>
+<tr id="row_0_116_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_116_" class="arrow" onclick="toggleFolder('0_116_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html" target="_self">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)></a></td><td class="desc">This specialization allow use of the sigc::signal<R(Args...)> syntax, </td></tr>
+<tr id="row_0_116_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal5.html" title="Signal declaration.">sigc::signal5</a> template </td></tr>
+<tr id="row_0_117_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_117_" class="arrow" onclick="toggleFolder('0_117_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html" target="_self">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)></a></td><td class="desc">This specialization allow use of the sigc::signal<R(Args...)> syntax, </td></tr>
+<tr id="row_0_117_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal6.html" title="Signal declaration.">sigc::signal6</a> template </td></tr>
+<tr id="row_0_118_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_118_" class="arrow" onclick="toggleFolder('0_118_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html" target="_self">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)></a></td><td class="desc">This specialization allow use of the sigc::signal<R(Args...)> syntax, </td></tr>
+<tr id="row_0_118_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates </td></tr>
+<tr id="row_0_119_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_119_" class="arrow" onclick="toggleFolder('0_119_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">signal< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal0.html" title="Signal declaration.">sigc::signal0</a> template </td></tr>
+<tr id="row_0_119_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal0.html" title="Signal declaration.">sigc::signal0</a> template </td></tr>
+<tr id="row_0_120_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_120_" class="arrow" onclick="toggleFolder('0_120_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal1.html" title="Signal declaration.">sigc::signal1</a> template </td></tr>
+<tr id="row_0_120_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal1.html" title="Signal declaration.">sigc::signal1</a> template </td></tr>
+<tr id="row_0_121_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_121_" class="arrow" onclick="toggleFolder('0_121_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal2.html" title="Signal declaration.">sigc::signal2</a> template </td></tr>
+<tr id="row_0_121_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal2.html" title="Signal declaration.">sigc::signal2</a> template </td></tr>
+<tr id="row_0_122_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_122_" class="arrow" onclick="toggleFolder('0_122_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal3.html" title="Signal declaration.">sigc::signal3</a> template </td></tr>
+<tr id="row_0_122_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal3.html" title="Signal declaration.">sigc::signal3</a> template </td></tr>
+<tr id="row_0_123_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_123_" class="arrow" onclick="toggleFolder('0_123_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal4.html" title="Signal declaration.">sigc::signal4</a> template </td></tr>
+<tr id="row_0_123_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal4.html" title="Signal declaration.">sigc::signal4</a> template </td></tr>
+<tr id="row_0_124_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_124_" class="arrow" onclick="toggleFolder('0_124_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html" target="_self">signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal5.html" title="Signal declaration.">sigc::signal5</a> template </td></tr>
+<tr id="row_0_124_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal5.html" title="Signal declaration.">sigc::signal5</a> template </td></tr>
+<tr id="row_0_125_" style="display:none;"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span id="arr_0_125_" class="arrow" onclick="toggleFolder('0_125_')">►</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html" target="_self">signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal6.html" title="Signal declaration.">sigc::signal6</a> template </td></tr>
+<tr id="row_0_125_0_" style="display:none;"><td class="entry"><span style="width:48px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html" target="_self">accumulated</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal6.html" title="Signal declaration.">sigc::signal6</a> template </td></tr>
+<tr id="row_0_126_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1signal__base.html" target="_self">signal_base</a></td><td class="desc">Base class for the <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates </td></tr>
+<tr id="row_0_127_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot.html" target="_self">slot</a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a># templates </td></tr>
+<tr id="row_0_128_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot0.html" target="_self">slot0</a></td><td class="desc">Converts an arbitrary functor to a unified type which is opaque </td></tr>
+<tr id="row_0_129_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot1.html" target="_self">slot1</a></td><td class="desc">Converts an arbitrary functor to a unified type which is opaque </td></tr>
+<tr id="row_0_130_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot2.html" target="_self">slot2</a></td><td class="desc">Converts an arbitrary functor to a unified type which is opaque </td></tr>
+<tr id="row_0_131_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot3.html" target="_self">slot3</a></td><td class="desc">Converts an arbitrary functor to a unified type which is opaque </td></tr>
+<tr id="row_0_132_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot4.html" target="_self">slot4</a></td><td class="desc">Converts an arbitrary functor to a unified type which is opaque </td></tr>
+<tr id="row_0_133_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot5.html" target="_self">slot5</a></td><td class="desc">Converts an arbitrary functor to a unified type which is opaque </td></tr>
+<tr id="row_0_134_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot6.html" target="_self">slot6</a></td><td class="desc">Converts an arbitrary functor to a unified type which is opaque </td></tr>
+<tr id="row_0_135_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot7.html" target="_self">slot7</a></td><td class="desc">Converts an arbitrary functor to a unified type which is opaque </td></tr>
+<tr id="row_0_136_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html" target="_self">slot< T_return(T_arg...)></a></td><td class="desc">Converts an arbitrary functor to a unified type which is opaque </td></tr>
+<tr id="row_0_137_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">slot< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot0.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot0</a> template </td></tr>
+<tr id="row_0_138_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot1.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot1</a> template </td></tr>
+<tr id="row_0_139_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot2.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot2</a> template </td></tr>
+<tr id="row_0_140_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot3.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot3</a> template </td></tr>
+<tr id="row_0_141_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html" target="_self">slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot4.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot4</a> template </td></tr>
+<tr id="row_0_142_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html" target="_self">slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot5.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot5</a> template </td></tr>
+<tr id="row_0_143_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html" target="_self">slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td><td class="desc">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot6.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot6</a> template </td></tr>
+<tr id="row_0_144_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1slot__base.html" target="_self">slot_base</a></td><td class="desc">Base type for slots </td></tr>
+<tr id="row_0_145_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1slot__const__iterator.html" target="_self">slot_const_iterator</a></td><td class="desc">STL-style const iterator for <a class="el" href="structsigc_1_1slot__list.html" title="STL-style list interface for sigc::signal#.">slot_list</a> </td></tr>
+<tr id="row_0_146_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1slot__iterator.html" target="_self">slot_iterator</a></td><td class="desc">STL-style iterator for <a class="el" href="structsigc_1_1slot__list.html" title="STL-style list interface for sigc::signal#.">slot_list</a> </td></tr>
+<tr id="row_0_147_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1slot__list.html" target="_self">slot_list</a></td><td class="desc">STL-style list interface for <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># </td></tr>
+<tr id="row_0_148_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1track__obj__functor1.html" target="_self">track_obj_functor1</a></td><td class="desc">Track_obj_functor1 wraps a functor and stores a reference to a trackable object </td></tr>
+<tr id="row_0_149_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1track__obj__functor2.html" target="_self">track_obj_functor2</a></td><td class="desc">Track_obj_functor2 wraps a functor and stores 2 references to trackable objects </td></tr>
+<tr id="row_0_150_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1track__obj__functor3.html" target="_self">track_obj_functor3</a></td><td class="desc">Track_obj_functor3 wraps a functor and stores 3 references to trackable objects </td></tr>
+<tr id="row_0_151_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1track__obj__functor4.html" target="_self">track_obj_functor4</a></td><td class="desc">Track_obj_functor4 wraps a functor and stores 4 references to trackable objects </td></tr>
+<tr id="row_0_152_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1track__obj__functor5.html" target="_self">track_obj_functor5</a></td><td class="desc">Track_obj_functor5 wraps a functor and stores 5 references to trackable objects </td></tr>
+<tr id="row_0_153_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1track__obj__functor6.html" target="_self">track_obj_functor6</a></td><td class="desc">Track_obj_functor6 wraps a functor and stores 6 references to trackable objects </td></tr>
+<tr id="row_0_154_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1track__obj__functor7.html" target="_self">track_obj_functor7</a></td><td class="desc">Track_obj_functor7 wraps a functor and stores 7 references to trackable objects </td></tr>
+<tr id="row_0_155_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1trackable.html" target="_self">trackable</a></td><td class="desc">Base class for objects with auto-disconnection </td></tr>
+<tr id="row_0_156_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1type__trait.html" target="_self">type_trait</a></td><td class="desc"></td></tr>
+<tr id="row_0_157_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html" target="_self">type_trait< const T_type & ></a></td><td class="desc"></td></tr>
+<tr id="row_0_158_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1type__trait_3_01T__type_01_6_01_4.html" target="_self">type_trait< T_type & ></a></td><td class="desc"></td></tr>
+<tr id="row_0_159_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html" target="_self">type_trait< T_type[N]></a></td><td class="desc"></td></tr>
+<tr id="row_0_160_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1type__trait_3_01void_01_4.html" target="_self">type_trait< void ></a></td><td class="desc"></td></tr>
+<tr id="row_0_161_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1unwrap__reference.html" target="_self">unwrap_reference</a></td><td class="desc"></td></tr>
+<tr id="row_0_162_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1unwrap__reference_3_01const__reference__wrapper_3_01T__type_01_4_01_4.html" target="_self">unwrap_reference< const_reference_wrapper< T_type > ></a></td><td class="desc"></td></tr>
+<tr id="row_0_163_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1unwrap__reference_3_01reference__wrapper_3_01T__type_01_4_01_4.html" target="_self">unwrap_reference< reference_wrapper< T_type > ></a></td><td class="desc"></td></tr>
+<tr id="row_0_164_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1unwrap__reference_3_01std_1_1reference__wrapper_3_01T__type_01_4_01_4.html" target="_self">unwrap_reference< std::reference_wrapper< T_type > ></a></td><td class="desc"></td></tr>
+<tr id="row_0_165_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="structsigc_1_1visitor.html" target="_self">visitor</a></td><td class="desc">Sigc::visitor<T_functor>::do_visit_each() performs a functor on each of the targets of a functor </td></tr>
+<tr id="row_0_166_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__limit__reference.html" target="_self">volatile_limit_reference</a></td><td class="desc">A volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>, then <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each<>()</a> will "limit" itself to the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference instead of the derived reference </td></tr>
+<tr id="row_0_167_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html" target="_self">volatile_limit_reference< T_type, true ></a></td><td class="desc">Volatile_limit_reference object for a class that derives from trackable </td></tr>
+<tr id="row_0_168_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__mem__functor0.html" target="_self">volatile_mem_functor0</a></td><td class="desc">Volatile_mem_functor0 wraps volatile methods with 0 argument(s) </td></tr>
+<tr id="row_0_169_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__mem__functor1.html" target="_self">volatile_mem_functor1</a></td><td class="desc">Volatile_mem_functor1 wraps volatile methods with 1 argument(s) </td></tr>
+<tr id="row_0_170_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__mem__functor2.html" target="_self">volatile_mem_functor2</a></td><td class="desc">Volatile_mem_functor2 wraps volatile methods with 2 argument(s) </td></tr>
+<tr id="row_0_171_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__mem__functor3.html" target="_self">volatile_mem_functor3</a></td><td class="desc">Volatile_mem_functor3 wraps volatile methods with 3 argument(s) </td></tr>
+<tr id="row_0_172_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__mem__functor4.html" target="_self">volatile_mem_functor4</a></td><td class="desc">Volatile_mem_functor4 wraps volatile methods with 4 argument(s) </td></tr>
+<tr id="row_0_173_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__mem__functor5.html" target="_self">volatile_mem_functor5</a></td><td class="desc">Volatile_mem_functor5 wraps volatile methods with 5 argument(s) </td></tr>
+<tr id="row_0_174_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__mem__functor6.html" target="_self">volatile_mem_functor6</a></td><td class="desc">Volatile_mem_functor6 wraps volatile methods with 6 argument(s) </td></tr>
+<tr id="row_0_175_" style="display:none;"><td class="entry"><span style="width:32px;display:inline-block;"> </span><span class="icona"><span class="icon">C</span></span><a class="el" href="classsigc_1_1volatile__mem__functor7.html" target="_self">volatile_mem_functor7</a></td><td class="desc">Volatile_mem_functor7 wraps volatile methods with 7 argument(s) </td></tr>
+<tr id="row_1_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><span class="icona"><span class="icon">N</span></span><b>std</b></td><td class="desc"></td></tr>
+</table>
+</div><!-- directory -->
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc Namespace Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#nested-classes">Classes</a> |
+<a href="#typedef-members">Typedefs</a> |
+<a href="#func-members">Functions</a> </div>
+ <div class="headertitle">
+<div class="title">sigc Namespace Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>The libsigc++ namespace.
+<a href="namespacesigc.html#details">More...</a></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Classes</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adaptor__base.html">adaptor_base</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">A hint to the compiler. <a href="structsigc_1_1adaptor__base.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adaptor__functor.html">adaptor_functor</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Converts an arbitrary functor into an adaptor type. <a href="structsigc_1_1adaptor__functor.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Trait that specifies what is the adaptor version of a functor type. <a href="structsigc_1_1adaptor__trait.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html">adaptor_trait< T_functor, false ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Trait that specifies what is the adaptor version of a functor type. <a href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html">adaptor_trait< T_functor, true ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Trait that specifies what is the adaptor version of a functor type. <a href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html">adapts</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Base type for adaptors. <a href="structsigc_1_1adapts.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that binds an argument to the wrapped functor. <a href="structsigc_1_1bind__functor.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that binds an argument to the wrapped functor. <a href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that binds 1 argument(s) to the wrapped functor. <a href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__return__functor.html">bind_return_functor</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that fixes the return value of the wrapped functor. <a href="structsigc_1_1bind__return__functor.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__argument.html">bound_argument</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">A bound_argument<Foo> object stores a bound (for instance, with <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">sigc::bind()</a>, or <a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a" title="Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed funct...">sigc::bind_return()</a>) argument. <a href="classsigc_1_1bound__argument.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html">bound_argument< const_reference_wrapper< T_wrapped > ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__argument.html" title="A bound_argument<Foo> object stores a bound (for instance, with sigc::bind(), or sigc::bind_return())...">bound_argument</a> object for a bound argument that is passed by <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">bind()</a> or returned by <a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a" title="Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed funct...">bind_return()</a> by const reference, specialized for const reference_wrapper<> types. <a href="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html">bound_argument< reference_wrapper< T_wrapped > ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__argument.html" title="A bound_argument<Foo> object stores a bound (for instance, with sigc::bind(), or sigc::bind_return())...">bound_argument</a> object for a bound argument that is passed by <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">bind()</a> or returned by <a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a" title="Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed funct...">bind_return()</a> by reference, specialized for reference_wrapper<> types. <a href="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html">bound_argument< std::reference_wrapper< T_wrapped > ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__argument.html" title="A bound_argument<Foo> object stores a bound (for instance, with sigc::bind(), or sigc::bind_return())...">bound_argument</a> object for a bound argument that is passed by <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">bind()</a> or returned by <a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a" title="Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed funct...">bind_return()</a> by reference, specialized for std::reference_wrapper<> types. <a href="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html">bound_const_mem_functor0</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html" title="bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance.">bound_const_mem_functor0</a> encapsulates a const method with 0 arguments and an object instance. <a href="classsigc_1_1bound__const__mem__functor0.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html">bound_const_mem_functor1</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html" title="bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance.">bound_const_mem_functor1</a> encapsulates a const method with 1 arguments and an object instance. <a href="classsigc_1_1bound__const__mem__functor1.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html">bound_const_mem_functor2</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html" title="bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance.">bound_const_mem_functor2</a> encapsulates a const method with 2 arguments and an object instance. <a href="classsigc_1_1bound__const__mem__functor2.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html">bound_const_mem_functor3</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html" title="bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance.">bound_const_mem_functor3</a> encapsulates a const method with 3 arguments and an object instance. <a href="classsigc_1_1bound__const__mem__functor3.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html">bound_const_mem_functor4</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html" title="bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance.">bound_const_mem_functor4</a> encapsulates a const method with 4 arguments and an object instance. <a href="classsigc_1_1bound__const__mem__functor4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html">bound_const_mem_functor5</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html" title="bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance.">bound_const_mem_functor5</a> encapsulates a const method with 5 arguments and an object instance. <a href="classsigc_1_1bound__const__mem__functor5.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html">bound_const_mem_functor6</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html" title="bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance.">bound_const_mem_functor6</a> encapsulates a const method with 6 arguments and an object instance. <a href="classsigc_1_1bound__const__mem__functor6.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html">bound_const_mem_functor7</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html" title="bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance.">bound_const_mem_functor7</a> encapsulates a const method with 7 arguments and an object instance. <a href="classsigc_1_1bound__const__mem__functor7.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">bound_const_volatile_mem_functor0</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html" title="bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object...">bound_const_volatile_mem_functor0</a> encapsulates a const volatile method with 0 arguments and an object instance. <a href="classsigc_1_1bound__const__volatile__mem__functor0.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">bound_const_volatile_mem_functor1</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html" title="bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object...">bound_const_volatile_mem_functor1</a> encapsulates a const volatile method with 1 arguments and an object instance. <a href="classsigc_1_1bound__const__volatile__mem__functor1.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">bound_const_volatile_mem_functor2</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html" title="bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object...">bound_const_volatile_mem_functor2</a> encapsulates a const volatile method with 2 arguments and an object instance. <a href="classsigc_1_1bound__const__volatile__mem__functor2.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">bound_const_volatile_mem_functor3</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html" title="bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object...">bound_const_volatile_mem_functor3</a> encapsulates a const volatile method with 3 arguments and an object instance. <a href="classsigc_1_1bound__const__volatile__mem__functor3.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">bound_const_volatile_mem_functor4</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html" title="bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object...">bound_const_volatile_mem_functor4</a> encapsulates a const volatile method with 4 arguments and an object instance. <a href="classsigc_1_1bound__const__volatile__mem__functor4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">bound_const_volatile_mem_functor5</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html" title="bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object...">bound_const_volatile_mem_functor5</a> encapsulates a const volatile method with 5 arguments and an object instance. <a href="classsigc_1_1bound__const__volatile__mem__functor5.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">bound_const_volatile_mem_functor6</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html" title="bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object...">bound_const_volatile_mem_functor6</a> encapsulates a const volatile method with 6 arguments and an object instance. <a href="classsigc_1_1bound__const__volatile__mem__functor6.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">bound_const_volatile_mem_functor7</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html" title="bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object...">bound_const_volatile_mem_functor7</a> encapsulates a const volatile method with 7 arguments and an object instance. <a href="classsigc_1_1bound__const__volatile__mem__functor7.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor0.html">bound_mem_functor0</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__mem__functor0.html" title="bound_mem_functor0 encapsulates a method with 0 arguments and an object instance.">bound_mem_functor0</a> encapsulates a method with 0 arguments and an object instance. <a href="classsigc_1_1bound__mem__functor0.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor1.html">bound_mem_functor1</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__mem__functor1.html" title="bound_mem_functor1 encapsulates a method with 1 arguments and an object instance.">bound_mem_functor1</a> encapsulates a method with 1 arguments and an object instance. <a href="classsigc_1_1bound__mem__functor1.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor2.html">bound_mem_functor2</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__mem__functor2.html" title="bound_mem_functor2 encapsulates a method with 2 arguments and an object instance.">bound_mem_functor2</a> encapsulates a method with 2 arguments and an object instance. <a href="classsigc_1_1bound__mem__functor2.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor3.html">bound_mem_functor3</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__mem__functor3.html" title="bound_mem_functor3 encapsulates a method with 3 arguments and an object instance.">bound_mem_functor3</a> encapsulates a method with 3 arguments and an object instance. <a href="classsigc_1_1bound__mem__functor3.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor4.html">bound_mem_functor4</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__mem__functor4.html" title="bound_mem_functor4 encapsulates a method with 4 arguments and an object instance.">bound_mem_functor4</a> encapsulates a method with 4 arguments and an object instance. <a href="classsigc_1_1bound__mem__functor4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor5.html">bound_mem_functor5</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__mem__functor5.html" title="bound_mem_functor5 encapsulates a method with 5 arguments and an object instance.">bound_mem_functor5</a> encapsulates a method with 5 arguments and an object instance. <a href="classsigc_1_1bound__mem__functor5.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor6.html">bound_mem_functor6</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__mem__functor6.html" title="bound_mem_functor6 encapsulates a method with 6 arguments and an object instance.">bound_mem_functor6</a> encapsulates a method with 6 arguments and an object instance. <a href="classsigc_1_1bound__mem__functor6.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__mem__functor7.html">bound_mem_functor7</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__mem__functor7.html" title="bound_mem_functor7 encapsulates a method with 7 arguments and an object instance.">bound_mem_functor7</a> encapsulates a method with 7 arguments and an object instance. <a href="classsigc_1_1bound__mem__functor7.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">bound_volatile_mem_functor0</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html" title="bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance.">bound_volatile_mem_functor0</a> encapsulates a volatile method with 0 arguments and an object instance. <a href="classsigc_1_1bound__volatile__mem__functor0.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">bound_volatile_mem_functor1</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html" title="bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance.">bound_volatile_mem_functor1</a> encapsulates a volatile method with 1 arguments and an object instance. <a href="classsigc_1_1bound__volatile__mem__functor1.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">bound_volatile_mem_functor2</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html" title="bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance.">bound_volatile_mem_functor2</a> encapsulates a volatile method with 2 arguments and an object instance. <a href="classsigc_1_1bound__volatile__mem__functor2.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">bound_volatile_mem_functor3</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html" title="bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance.">bound_volatile_mem_functor3</a> encapsulates a volatile method with 3 arguments and an object instance. <a href="classsigc_1_1bound__volatile__mem__functor3.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">bound_volatile_mem_functor4</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html" title="bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance.">bound_volatile_mem_functor4</a> encapsulates a volatile method with 4 arguments and an object instance. <a href="classsigc_1_1bound__volatile__mem__functor4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">bound_volatile_mem_functor5</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html" title="bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance.">bound_volatile_mem_functor5</a> encapsulates a volatile method with 5 arguments and an object instance. <a href="classsigc_1_1bound__volatile__mem__functor5.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">bound_volatile_mem_functor6</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html" title="bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance.">bound_volatile_mem_functor6</a> encapsulates a volatile method with 6 arguments and an object instance. <a href="classsigc_1_1bound__volatile__mem__functor6.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">bound_volatile_mem_functor7</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html" title="bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance.">bound_volatile_mem_functor7</a> encapsulates a volatile method with 7 arguments and an object instance. <a href="classsigc_1_1bound__volatile__mem__functor7.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1can__deduce__result__type__with__decltype.html">can_deduce_result_type_with_decltype</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Helper class, to determine if decltype() can deduce the result type of a functor. <a href="classsigc_1_1can__deduce__result__type__with__decltype.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose1__functor.html">compose1_functor</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that combines two functors. <a href="structsigc_1_1compose1__functor.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose2__functor.html">compose2_functor</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that combines three functors. <a href="structsigc_1_1compose2__functor.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1connection.html">connection</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convinience class for safe disconnection. <a href="structsigc_1_1connection.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__limit__reference.html">const_limit_reference</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">A const_limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>, then <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each<>()</a> will "limit" itself to the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference instead of the derived reference. <a href="classsigc_1_1const__limit__reference.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html">const_limit_reference< T_type, true ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__limit__reference.html" title="A const_limit_reference<Foo> object stores a reference (Foo&), but make sure that,...">const_limit_reference</a> object for a class that derives from trackable. <a href="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor0.html">const_mem_functor0</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__mem__functor0.html" title="const_mem_functor0 wraps const methods with 0 argument(s).">const_mem_functor0</a> wraps const methods with 0 argument(s). <a href="classsigc_1_1const__mem__functor0.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor1.html">const_mem_functor1</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__mem__functor1.html" title="const_mem_functor1 wraps const methods with 1 argument(s).">const_mem_functor1</a> wraps const methods with 1 argument(s). <a href="classsigc_1_1const__mem__functor1.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor2.html">const_mem_functor2</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__mem__functor2.html" title="const_mem_functor2 wraps const methods with 2 argument(s).">const_mem_functor2</a> wraps const methods with 2 argument(s). <a href="classsigc_1_1const__mem__functor2.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor3.html">const_mem_functor3</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__mem__functor3.html" title="const_mem_functor3 wraps const methods with 3 argument(s).">const_mem_functor3</a> wraps const methods with 3 argument(s). <a href="classsigc_1_1const__mem__functor3.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor4.html">const_mem_functor4</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__mem__functor4.html" title="const_mem_functor4 wraps const methods with 4 argument(s).">const_mem_functor4</a> wraps const methods with 4 argument(s). <a href="classsigc_1_1const__mem__functor4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor5.html">const_mem_functor5</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__mem__functor5.html" title="const_mem_functor5 wraps const methods with 5 argument(s).">const_mem_functor5</a> wraps const methods with 5 argument(s). <a href="classsigc_1_1const__mem__functor5.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor6.html">const_mem_functor6</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__mem__functor6.html" title="const_mem_functor6 wraps const methods with 6 argument(s).">const_mem_functor6</a> wraps const methods with 6 argument(s). <a href="classsigc_1_1const__mem__functor6.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__mem__functor7.html">const_mem_functor7</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__mem__functor7.html" title="const_mem_functor7 wraps const methods with 7 argument(s).">const_mem_functor7</a> wraps const methods with 7 argument(s). <a href="classsigc_1_1const__mem__functor7.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1const__reference__wrapper.html">const_reference_wrapper</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Const reference wrapper. <a href="structsigc_1_1const__reference__wrapper.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html">const_volatile_limit_reference</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">A const_volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>, then <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each<>()</a> will "limit" itself to the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference instead of the derived reference. <a href="classsigc_1_1const__volatile__limit__reference.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html">const_volatile_limit_reference< T_type, true ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__volatile__limit__reference.html" title="A const_volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that,...">const_volatile_limit_reference</a> object for a class that derives from trackable. <a href="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">const_volatile_mem_functor0</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html" title="const_volatile_mem_functor0 wraps const volatile methods with 0 argument(s).">const_volatile_mem_functor0</a> wraps const volatile methods with 0 argument(s). <a href="classsigc_1_1const__volatile__mem__functor0.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">const_volatile_mem_functor1</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html" title="const_volatile_mem_functor1 wraps const volatile methods with 1 argument(s).">const_volatile_mem_functor1</a> wraps const volatile methods with 1 argument(s). <a href="classsigc_1_1const__volatile__mem__functor1.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">const_volatile_mem_functor2</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html" title="const_volatile_mem_functor2 wraps const volatile methods with 2 argument(s).">const_volatile_mem_functor2</a> wraps const volatile methods with 2 argument(s). <a href="classsigc_1_1const__volatile__mem__functor2.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">const_volatile_mem_functor3</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html" title="const_volatile_mem_functor3 wraps const volatile methods with 3 argument(s).">const_volatile_mem_functor3</a> wraps const volatile methods with 3 argument(s). <a href="classsigc_1_1const__volatile__mem__functor3.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">const_volatile_mem_functor4</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html" title="const_volatile_mem_functor4 wraps const volatile methods with 4 argument(s).">const_volatile_mem_functor4</a> wraps const volatile methods with 4 argument(s). <a href="classsigc_1_1const__volatile__mem__functor4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">const_volatile_mem_functor5</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html" title="const_volatile_mem_functor5 wraps const volatile methods with 5 argument(s).">const_volatile_mem_functor5</a> wraps const volatile methods with 5 argument(s). <a href="classsigc_1_1const__volatile__mem__functor5.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">const_volatile_mem_functor6</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html" title="const_volatile_mem_functor6 wraps const volatile methods with 6 argument(s).">const_volatile_mem_functor6</a> wraps const volatile methods with 6 argument(s). <a href="classsigc_1_1const__volatile__mem__functor6.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">const_volatile_mem_functor7</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html" title="const_volatile_mem_functor7 wraps const volatile methods with 7 argument(s).">const_volatile_mem_functor7</a> wraps const volatile methods with 7 argument(s). <a href="classsigc_1_1const__volatile__mem__functor7.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Deduce the return type of a functor. <a href="structsigc_1_1deduce__result__type.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1exception__catch__functor.html">exception_catch_functor</a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html">exception_catch_functor< T_functor, T_catcher, void ></a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1functor__base.html">functor_base</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">A hint to the compiler. <a href="structsigc_1_1functor__base.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1functor__trait.html">functor_trait</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Trait that specifies the return type of any type. <a href="structsigc_1_1functor__trait.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1hide__functor.html">hide_functor</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that adds a dummy parameter to the wrapped functor. <a href="structsigc_1_1hide__functor.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html">hide_functor< 0, T_functor ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that adds a dummy parameter to the wrapped functor. <a href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html">hide_functor<-1, T_functor ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that adds a dummy parameter to the wrapped functor. <a href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1limit__reference.html">limit_reference</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">A limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>, then <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each<>()</a> will "limit" itself to the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference instead of the derived reference. <a href="classsigc_1_1limit__reference.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html">limit_reference< T_type, true ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1limit__reference.html" title="A limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from sig...">limit_reference</a> object for a class that derives from trackable. <a href="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor0.html">mem_functor0</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1mem__functor0.html" title="mem_functor0 wraps methods with 0 argument(s).">mem_functor0</a> wraps methods with 0 argument(s). <a href="classsigc_1_1mem__functor0.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor1.html">mem_functor1</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1mem__functor1.html" title="mem_functor1 wraps methods with 1 argument(s).">mem_functor1</a> wraps methods with 1 argument(s). <a href="classsigc_1_1mem__functor1.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor2.html">mem_functor2</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1mem__functor2.html" title="mem_functor2 wraps methods with 2 argument(s).">mem_functor2</a> wraps methods with 2 argument(s). <a href="classsigc_1_1mem__functor2.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor3.html">mem_functor3</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1mem__functor3.html" title="mem_functor3 wraps methods with 3 argument(s).">mem_functor3</a> wraps methods with 3 argument(s). <a href="classsigc_1_1mem__functor3.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor4.html">mem_functor4</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1mem__functor4.html" title="mem_functor4 wraps methods with 4 argument(s).">mem_functor4</a> wraps methods with 4 argument(s). <a href="classsigc_1_1mem__functor4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor5.html">mem_functor5</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1mem__functor5.html" title="mem_functor5 wraps methods with 5 argument(s).">mem_functor5</a> wraps methods with 5 argument(s). <a href="classsigc_1_1mem__functor5.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor6.html">mem_functor6</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1mem__functor6.html" title="mem_functor6 wraps methods with 6 argument(s).">mem_functor6</a> wraps methods with 6 argument(s). <a href="classsigc_1_1mem__functor6.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1mem__functor7.html">mem_functor7</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1mem__functor7.html" title="mem_functor7 wraps methods with 7 argument(s).">mem_functor7</a> wraps methods with 7 argument(s). <a href="classsigc_1_1mem__functor7.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1nil.html">nil</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">nil struct type. <a href="structsigc_1_1nil.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor0.html">pointer_functor0</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1pointer__functor0.html" title="pointer_functor0 wraps existing non-member functions with 0 argument(s).">pointer_functor0</a> wraps existing non-member functions with 0 argument(s). <a href="classsigc_1_1pointer__functor0.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor1.html">pointer_functor1</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1pointer__functor1.html" title="pointer_functor1 wraps existing non-member functions with 1 argument(s).">pointer_functor1</a> wraps existing non-member functions with 1 argument(s). <a href="classsigc_1_1pointer__functor1.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor2.html">pointer_functor2</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1pointer__functor2.html" title="pointer_functor2 wraps existing non-member functions with 2 argument(s).">pointer_functor2</a> wraps existing non-member functions with 2 argument(s). <a href="classsigc_1_1pointer__functor2.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor3.html">pointer_functor3</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1pointer__functor3.html" title="pointer_functor3 wraps existing non-member functions with 3 argument(s).">pointer_functor3</a> wraps existing non-member functions with 3 argument(s). <a href="classsigc_1_1pointer__functor3.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor4.html">pointer_functor4</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1pointer__functor4.html" title="pointer_functor4 wraps existing non-member functions with 4 argument(s).">pointer_functor4</a> wraps existing non-member functions with 4 argument(s). <a href="classsigc_1_1pointer__functor4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor5.html">pointer_functor5</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1pointer__functor5.html" title="pointer_functor5 wraps existing non-member functions with 5 argument(s).">pointer_functor5</a> wraps existing non-member functions with 5 argument(s). <a href="classsigc_1_1pointer__functor5.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor6.html">pointer_functor6</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1pointer__functor6.html" title="pointer_functor6 wraps existing non-member functions with 6 argument(s).">pointer_functor6</a> wraps existing non-member functions with 6 argument(s). <a href="classsigc_1_1pointer__functor6.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1pointer__functor7.html">pointer_functor7</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1pointer__functor7.html" title="pointer_functor7 wraps existing non-member functions with 7 argument(s).">pointer_functor7</a> wraps existing non-member functions with 7 argument(s). <a href="classsigc_1_1pointer__functor7.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1reference__wrapper.html">reference_wrapper</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Reference wrapper. <a href="structsigc_1_1reference__wrapper.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that performs C-style casts on the parameters passed on to the functor. <a href="structsigc_1_1retype__functor.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__return__functor.html">retype_return_functor</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that performs a C-style cast on the return value of a functor. <a href="structsigc_1_1retype__return__functor.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html">retype_return_functor< void, T_functor ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that performs a C-style cast on the return value of a functor. <a href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal.html">signal</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates. <a href="classsigc_1_1signal.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal0.html">signal0</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Signal declaration. <a href="classsigc_1_1signal0.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal1.html">signal1</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Signal declaration. <a href="classsigc_1_1signal1.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal2.html">signal2</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Signal declaration. <a href="classsigc_1_1signal2.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal3.html">signal3</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Signal declaration. <a href="classsigc_1_1signal3.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal4.html">signal4</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Signal declaration. <a href="classsigc_1_1signal4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal5.html">signal5</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Signal declaration. <a href="classsigc_1_1signal5.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal6.html">signal6</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Signal declaration. <a href="classsigc_1_1signal6.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal7.html">signal7</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Signal declaration. <a href="classsigc_1_1signal7.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html">signal< T_return(T_arg1)></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">This specialization allow use of the sigc::signal<R(Args...)> syntax,. <a href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html">signal< T_return(T_arg1, T_arg2)></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">This specialization allow use of the sigc::signal<R(Args...)> syntax,. <a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3)></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">This specialization allow use of the sigc::signal<R(Args...)> syntax,. <a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">This specialization allow use of the sigc::signal<R(Args...)> syntax,. <a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">This specialization allow use of the sigc::signal<R(Args...)> syntax,. <a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">This specialization allow use of the sigc::signal<R(Args...)> syntax,. <a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html">signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">This specialization allow use of the sigc::signal<R(Args...)> syntax,. <a href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal0.html" title="Signal declaration.">sigc::signal0</a> template. <a href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal1.html" title="Signal declaration.">sigc::signal1</a> template. <a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal2.html" title="Signal declaration.">sigc::signal2</a> template. <a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal3.html" title="Signal declaration.">sigc::signal3</a> template. <a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal4.html" title="Signal declaration.">sigc::signal4</a> template. <a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal5.html" title="Signal declaration.">sigc::signal5</a> template. <a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html">signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1signal6.html" title="Signal declaration.">sigc::signal6</a> template. <a href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Base class for the <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates. <a href="structsigc_1_1signal__base.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot.html">slot</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a># templates. <a href="classsigc_1_1slot.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot0.html">slot0</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Converts an arbitrary functor to a unified type which is opaque. <a href="classsigc_1_1slot0.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot1.html">slot1</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Converts an arbitrary functor to a unified type which is opaque. <a href="classsigc_1_1slot1.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot2.html">slot2</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Converts an arbitrary functor to a unified type which is opaque. <a href="classsigc_1_1slot2.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot3.html">slot3</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Converts an arbitrary functor to a unified type which is opaque. <a href="classsigc_1_1slot3.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot4.html">slot4</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Converts an arbitrary functor to a unified type which is opaque. <a href="classsigc_1_1slot4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot5.html">slot5</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Converts an arbitrary functor to a unified type which is opaque. <a href="classsigc_1_1slot5.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot6.html">slot6</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Converts an arbitrary functor to a unified type which is opaque. <a href="classsigc_1_1slot6.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot7.html">slot7</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Converts an arbitrary functor to a unified type which is opaque. <a href="classsigc_1_1slot7.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html">slot< T_return(T_arg...)></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Converts an arbitrary functor to a unified type which is opaque. <a href="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">slot< T_return, nil, nil, nil, nil, nil, nil, nil ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot0.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot0</a> template. <a href="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot1.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot1</a> template. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot2.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot2</a> template. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot3.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot3</a> template. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html">slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot4.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot4</a> template. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html">slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot5.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot5</a> template. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html">slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Convenience wrapper for the numbered <a class="el" href="classsigc_1_1slot6.html" title="Converts an arbitrary functor to a unified type which is opaque.">sigc::slot6</a> template. <a href="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Base type for slots. <a href="classsigc_1_1slot__base.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__const__iterator.html">slot_const_iterator</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">STL-style const iterator for <a class="el" href="structsigc_1_1slot__list.html" title="STL-style list interface for sigc::signal#.">slot_list</a>. <a href="structsigc_1_1slot__const__iterator.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__iterator.html">slot_iterator</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">STL-style iterator for <a class="el" href="structsigc_1_1slot__list.html" title="STL-style list interface for sigc::signal#.">slot_list</a>. <a href="structsigc_1_1slot__iterator.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html">slot_list</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">STL-style list interface for <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a>#. <a href="structsigc_1_1slot__list.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor1.html">track_obj_functor1</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object.">track_obj_functor1</a> wraps a functor and stores a reference to a trackable object. <a href="classsigc_1_1track__obj__functor1.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor2.html">track_obj_functor2</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1track__obj__functor2.html" title="track_obj_functor2 wraps a functor and stores 2 references to trackable objects.">track_obj_functor2</a> wraps a functor and stores 2 references to trackable objects. <a href="classsigc_1_1track__obj__functor2.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor3.html">track_obj_functor3</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1track__obj__functor3.html" title="track_obj_functor3 wraps a functor and stores 3 references to trackable objects.">track_obj_functor3</a> wraps a functor and stores 3 references to trackable objects. <a href="classsigc_1_1track__obj__functor3.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor4.html">track_obj_functor4</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1track__obj__functor4.html" title="track_obj_functor4 wraps a functor and stores 4 references to trackable objects.">track_obj_functor4</a> wraps a functor and stores 4 references to trackable objects. <a href="classsigc_1_1track__obj__functor4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor5.html">track_obj_functor5</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1track__obj__functor5.html" title="track_obj_functor5 wraps a functor and stores 5 references to trackable objects.">track_obj_functor5</a> wraps a functor and stores 5 references to trackable objects. <a href="classsigc_1_1track__obj__functor5.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor6.html">track_obj_functor6</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1track__obj__functor6.html" title="track_obj_functor6 wraps a functor and stores 6 references to trackable objects.">track_obj_functor6</a> wraps a functor and stores 6 references to trackable objects. <a href="classsigc_1_1track__obj__functor6.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1track__obj__functor7.html">track_obj_functor7</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1track__obj__functor7.html" title="track_obj_functor7 wraps a functor and stores 7 references to trackable objects.">track_obj_functor7</a> wraps a functor and stores 7 references to trackable objects. <a href="classsigc_1_1track__obj__functor7.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html">trackable</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">Base class for objects with auto-disconnection. <a href="structsigc_1_1trackable.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1type__trait.html">type_trait</a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html">type_trait< const T_type & ></a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1type__trait_3_01T__type_01_6_01_4.html">type_trait< T_type & ></a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html">type_trait< T_type[N]></a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1type__trait_3_01void_01_4.html">type_trait< void ></a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1unwrap__reference.html">unwrap_reference</a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1unwrap__reference_3_01const__reference__wrapper_3_01T__type_01_4_01_4.html">unwrap_reference< const_reference_wrapper< T_type > ></a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1unwrap__reference_3_01reference__wrapper_3_01T__type_01_4_01_4.html">unwrap_reference< reference_wrapper< T_type > ></a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1unwrap__reference_3_01std_1_1reference__wrapper_3_01T__type_01_4_01_4.html">unwrap_reference< std::reference_wrapper< T_type > ></a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct  </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1visitor.html">visitor</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="structsigc_1_1visitor.html#a9fe5d6be845e622a99a0db5d3621d4b3">sigc::visitor<T_functor>::do_visit_each()</a> performs a functor on each of the targets of a functor. <a href="structsigc_1_1visitor.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__limit__reference.html">volatile_limit_reference</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight">A volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a>, then <a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" title="This function performs a functor on each of the targets of a functor.">visit_each<>()</a> will "limit" itself to the <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> reference instead of the derived reference. <a href="classsigc_1_1volatile__limit__reference.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html">volatile_limit_reference< T_type, true ></a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1volatile__limit__reference.html" title="A volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that,...">volatile_limit_reference</a> object for a class that derives from trackable. <a href="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor0.html">volatile_mem_functor0</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1volatile__mem__functor0.html" title="volatile_mem_functor0 wraps volatile methods with 0 argument(s).">volatile_mem_functor0</a> wraps volatile methods with 0 argument(s). <a href="classsigc_1_1volatile__mem__functor0.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor1.html">volatile_mem_functor1</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1volatile__mem__functor1.html" title="volatile_mem_functor1 wraps volatile methods with 1 argument(s).">volatile_mem_functor1</a> wraps volatile methods with 1 argument(s). <a href="classsigc_1_1volatile__mem__functor1.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor2.html">volatile_mem_functor2</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1volatile__mem__functor2.html" title="volatile_mem_functor2 wraps volatile methods with 2 argument(s).">volatile_mem_functor2</a> wraps volatile methods with 2 argument(s). <a href="classsigc_1_1volatile__mem__functor2.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor3.html">volatile_mem_functor3</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1volatile__mem__functor3.html" title="volatile_mem_functor3 wraps volatile methods with 3 argument(s).">volatile_mem_functor3</a> wraps volatile methods with 3 argument(s). <a href="classsigc_1_1volatile__mem__functor3.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor4.html">volatile_mem_functor4</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1volatile__mem__functor4.html" title="volatile_mem_functor4 wraps volatile methods with 4 argument(s).">volatile_mem_functor4</a> wraps volatile methods with 4 argument(s). <a href="classsigc_1_1volatile__mem__functor4.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor5.html">volatile_mem_functor5</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1volatile__mem__functor5.html" title="volatile_mem_functor5 wraps volatile methods with 5 argument(s).">volatile_mem_functor5</a> wraps volatile methods with 5 argument(s). <a href="classsigc_1_1volatile__mem__functor5.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor6.html">volatile_mem_functor6</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1volatile__mem__functor6.html" title="volatile_mem_functor6 wraps volatile methods with 6 argument(s).">volatile_mem_functor6</a> wraps volatile methods with 6 argument(s). <a href="classsigc_1_1volatile__mem__functor6.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class  </td><td class="memItemRight" valign="bottom"><a class="el" href="classsigc_1_1volatile__mem__functor7.html">volatile_mem_functor7</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft"> </td><td class="mdescRight"><a class="el" href="classsigc_1_1volatile__mem__functor7.html" title="volatile_mem_functor7 wraps volatile methods with 7 argument(s).">volatile_mem_functor7</a> wraps volatile methods with 7 argument(s). <a href="classsigc_1_1volatile__mem__functor7.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="typedef-members"></a>
+Typedefs</h2></td></tr>
+<tr class="memitem:ab7791439fb79592300826fe076a8e3d1"><td class="memTemplParams" colspan="2">template<typename T_functor , typename... T_args> </td></tr>
+<tr class="memitem:ab7791439fb79592300826fe076a8e3d1"><td class="memTemplItemLeft" align="right" valign="top">using </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ab7791439fb79592300826fe076a8e3d1">deduce_result_t</a> = typename <a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_functor, T_args... >::type</td></tr>
+<tr class="separator:ab7791439fb79592300826fe076a8e3d1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa2d13c7fc829cfec6e0f9d5092f2aa79"><td class="memTemplParams" colspan="2">template<typename T > </td></tr>
+<tr class="memitem:aa2d13c7fc829cfec6e0f9d5092f2aa79"><td class="memTemplItemLeft" align="right" valign="top">using </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#aa2d13c7fc829cfec6e0f9d5092f2aa79">type_trait_pass_t</a> = typename <a class="el" href="structsigc_1_1type__trait.html">type_trait</a>< T >::pass</td></tr>
+<tr class="separator:aa2d13c7fc829cfec6e0f9d5092f2aa79"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa0d56c61023af35c47b79db80b32fd2e"><td class="memTemplParams" colspan="2">template<typename T > </td></tr>
+<tr class="memitem:aa0d56c61023af35c47b79db80b32fd2e"><td class="memTemplItemLeft" align="right" valign="top">using </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a> = typename <a class="el" href="structsigc_1_1type__trait.html">type_trait</a>< T >::take</td></tr>
+<tr class="separator:aa0d56c61023af35c47b79db80b32fd2e"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
+Functions</h2></td></tr>
+<tr class="memitem:ga2f099bc6056b32f2a58134ba8537c6f4"><td class="memTemplParams" colspan="2">template<int I_location, class T_bound1 , class T_functor > </td></tr>
+<tr class="memitem:ga2f099bc6056b32f2a58134ba8537c6f4"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a>< I_location, T_functor, T_bound1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4">bind</a> (const T_functor & _A_func, T_bound1 _A_b1)</td></tr>
+<tr class="memdesc:ga2f099bc6056b32f2a58134ba8537c6f4"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">sigc::bind_functor</a> which binds the passed argument to the passed functor. <a href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4">More...</a><br /></td></tr>
+<tr class="separator:ga2f099bc6056b32f2a58134ba8537c6f4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga211b3361bb1ae7484b2b276fd926b962"><td class="memTemplParams" colspan="2">template<class T_type1 , class T_functor > </td></tr>
+<tr class="memitem:ga211b3361bb1ae7484b2b276fd926b962"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a><-1, T_functor, T_type1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__bind.html#ga211b3361bb1ae7484b2b276fd926b962">bind</a> (const T_functor & _A_func, T_type1 _A_b1)</td></tr>
+<tr class="memdesc:ga211b3361bb1ae7484b2b276fd926b962"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">sigc::bind_functor</a> which fixes the last 1 argument(s) of the passed functor. <a href="group__bind.html#ga211b3361bb1ae7484b2b276fd926b962">More...</a><br /></td></tr>
+<tr class="separator:ga211b3361bb1ae7484b2b276fd926b962"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaf1e076f0734addb8080f1cbcac602591"><td class="memTemplParams" colspan="2">template<class T_type1 , class T_type2 , class T_functor > </td></tr>
+<tr class="memitem:gaf1e076f0734addb8080f1cbcac602591"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a><-1, T_functor, T_type1, T_type2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__bind.html#gaf1e076f0734addb8080f1cbcac602591">bind</a> (const T_functor & _A_func, T_type1 _A_b1, T_type2 _A_b2)</td></tr>
+<tr class="memdesc:gaf1e076f0734addb8080f1cbcac602591"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">sigc::bind_functor</a> which fixes the last 2 argument(s) of the passed functor. <a href="group__bind.html#gaf1e076f0734addb8080f1cbcac602591">More...</a><br /></td></tr>
+<tr class="separator:gaf1e076f0734addb8080f1cbcac602591"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga047061c9fa7d9dcde68c27cceed476a1"><td class="memTemplParams" colspan="2">template<class T_type1 , class T_type2 , class T_type3 , class T_functor > </td></tr>
+<tr class="memitem:ga047061c9fa7d9dcde68c27cceed476a1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a><-1, T_functor, T_type1, T_type2, T_type3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__bind.html#ga047061c9fa7d9dcde68c27cceed476a1">bind</a> (const T_functor & _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3)</td></tr>
+<tr class="memdesc:ga047061c9fa7d9dcde68c27cceed476a1"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">sigc::bind_functor</a> which fixes the last 3 argument(s) of the passed functor. <a href="group__bind.html#ga047061c9fa7d9dcde68c27cceed476a1">More...</a><br /></td></tr>
+<tr class="separator:ga047061c9fa7d9dcde68c27cceed476a1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga8366abceb86ee653ec2ac50cef9fd16d"><td class="memTemplParams" colspan="2">template<class T_type1 , class T_type2 , class T_type3 , class T_type4 , class T_functor > </td></tr>
+<tr class="memitem:ga8366abceb86ee653ec2ac50cef9fd16d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a><-1, T_functor, T_type1, T_type2, T_type3, T_type4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__bind.html#ga8366abceb86ee653ec2ac50cef9fd16d">bind</a> (const T_functor & _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4)</td></tr>
+<tr class="memdesc:ga8366abceb86ee653ec2ac50cef9fd16d"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">sigc::bind_functor</a> which fixes the last 4 argument(s) of the passed functor. <a href="group__bind.html#ga8366abceb86ee653ec2ac50cef9fd16d">More...</a><br /></td></tr>
+<tr class="separator:ga8366abceb86ee653ec2ac50cef9fd16d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga7f163c830d7906906cf21ff0c5e0f17f"><td class="memTemplParams" colspan="2">template<class T_type1 , class T_type2 , class T_type3 , class T_type4 , class T_type5 , class T_functor > </td></tr>
+<tr class="memitem:ga7f163c830d7906906cf21ff0c5e0f17f"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a><-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__bind.html#ga7f163c830d7906906cf21ff0c5e0f17f">bind</a> (const T_functor & _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4, T_type5 _A_b5)</td></tr>
+<tr class="memdesc:ga7f163c830d7906906cf21ff0c5e0f17f"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">sigc::bind_functor</a> which fixes the last 5 argument(s) of the passed functor. <a href="group__bind.html#ga7f163c830d7906906cf21ff0c5e0f17f">More...</a><br /></td></tr>
+<tr class="separator:ga7f163c830d7906906cf21ff0c5e0f17f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gac370f58b773f68c229c181f07e9b9e79"><td class="memTemplParams" colspan="2">template<class T_type1 , class T_type2 , class T_type3 , class T_type4 , class T_type5 , class T_type6 , class T_functor > </td></tr>
+<tr class="memitem:gac370f58b773f68c229c181f07e9b9e79"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a><-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__bind.html#gac370f58b773f68c229c181f07e9b9e79">bind</a> (const T_functor & _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4, T_type5 _A_b5, T_type6 _A_b6)</td></tr>
+<tr class="memdesc:gac370f58b773f68c229c181f07e9b9e79"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">sigc::bind_functor</a> which fixes the last 6 argument(s) of the passed functor. <a href="group__bind.html#gac370f58b773f68c229c181f07e9b9e79">More...</a><br /></td></tr>
+<tr class="separator:gac370f58b773f68c229c181f07e9b9e79"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga962b581ef0c17562bb3317783d3ffe7d"><td class="memTemplParams" colspan="2">template<class T_type1 , class T_type2 , class T_type3 , class T_type4 , class T_type5 , class T_type6 , class T_type7 , class T_functor > </td></tr>
+<tr class="memitem:ga962b581ef0c17562bb3317783d3ffe7d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a><-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__bind.html#ga962b581ef0c17562bb3317783d3ffe7d">bind</a> (const T_functor & _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4, T_type5 _A_b5, T_type6 _A_b6, T_type7 _A_b7)</td></tr>
+<tr class="memdesc:ga962b581ef0c17562bb3317783d3ffe7d"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">sigc::bind_functor</a> which fixes the last 7 argument(s) of the passed functor. <a href="group__bind.html#ga962b581ef0c17562bb3317783d3ffe7d">More...</a><br /></td></tr>
+<tr class="separator:ga962b581ef0c17562bb3317783d3ffe7d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaca1ae2466988d67d00a5f2cd16c8d90a"><td class="memTemplParams" colspan="2">template<class T_return , class T_functor > </td></tr>
+<tr class="memitem:gaca1ae2466988d67d00a5f2cd16c8d90a"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1bind__return__functor.html">bind_return_functor</a>< T_return, T_functor > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a">bind_return</a> (const T_functor & _A_functor, T_return _A_ret_value)</td></tr>
+<tr class="memdesc:gaca1ae2466988d67d00a5f2cd16c8d90a"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1bind__return__functor.html" title="Adaptor that fixes the return value of the wrapped functor.">sigc::bind_return_functor</a> which fixes the return value of the passed functor to the passed argument. <a href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a">More...</a><br /></td></tr>
+<tr class="separator:gaca1ae2466988d67d00a5f2cd16c8d90a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga34cf5da8f6323bfdc41bc7113d6ad20a"><td class="memTemplParams" colspan="2">template<class T_setter , class T_getter > </td></tr>
+<tr class="memitem:ga34cf5da8f6323bfdc41bc7113d6ad20a"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1compose1__functor.html">compose1_functor</a>< T_setter, T_getter > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__compose.html#ga34cf5da8f6323bfdc41bc7113d6ad20a">compose</a> (const T_setter & _A_setter, const T_getter & _A_getter)</td></tr>
+<tr class="memdesc:ga34cf5da8f6323bfdc41bc7113d6ad20a"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1compose1__functor.html" title="Adaptor that combines two functors.">sigc::compose1_functor</a> which combines two functors. <a href="group__compose.html#ga34cf5da8f6323bfdc41bc7113d6ad20a">More...</a><br /></td></tr>
+<tr class="separator:ga34cf5da8f6323bfdc41bc7113d6ad20a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga4abf2a45eb2307a3dc5d870c86b0450d"><td class="memTemplParams" colspan="2">template<class T_setter , class T_getter1 , class T_getter2 > </td></tr>
+<tr class="memitem:ga4abf2a45eb2307a3dc5d870c86b0450d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1compose2__functor.html">compose2_functor</a>< T_setter, T_getter1, T_getter2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__compose.html#ga4abf2a45eb2307a3dc5d870c86b0450d">compose</a> (const T_setter & _A_setter, const T_getter1 & _A_getter1, const T_getter2 & _A_getter2)</td></tr>
+<tr class="memdesc:ga4abf2a45eb2307a3dc5d870c86b0450d"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1compose2__functor.html" title="Adaptor that combines three functors.">sigc::compose2_functor</a> which combines three functors. <a href="group__compose.html#ga4abf2a45eb2307a3dc5d870c86b0450d">More...</a><br /></td></tr>
+<tr class="separator:ga4abf2a45eb2307a3dc5d870c86b0450d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0ae3b8a1ba26920cee4d7d9df2c39ed9"><td class="memTemplParams" colspan="2">template<class T_functor , class T_catcher > </td></tr>
+<tr class="memitem:a0ae3b8a1ba26920cee4d7d9df2c39ed9"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1exception__catch__functor.html">exception_catch_functor</a>< T_functor, T_catcher > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#a0ae3b8a1ba26920cee4d7d9df2c39ed9">exception_catch</a> (const T_functor & _A_func, const T_catcher & _A_catcher)</td></tr>
+<tr class="separator:a0ae3b8a1ba26920cee4d7d9df2c39ed9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaf2cefea3a99acd44f68121424103172d"><td class="memTemplParams" colspan="2">template<int I_location, class T_functor > </td></tr>
+<tr class="memitem:gaf2cefea3a99acd44f68121424103172d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1hide__functor.html">hide_functor</a>< I_location, T_functor > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__hide.html#gaf2cefea3a99acd44f68121424103172d">hide</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:gaf2cefea3a99acd44f68121424103172d"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1hide__functor.html" title="Adaptor that adds a dummy parameter to the wrapped functor.">sigc::hide_functor</a> which adds a dummy parameter to the passed functor. <a href="group__hide.html#gaf2cefea3a99acd44f68121424103172d">More...</a><br /></td></tr>
+<tr class="separator:gaf2cefea3a99acd44f68121424103172d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gacbbacd3553268d85b95e3a85aefb67e5"><td class="memTemplParams" colspan="2">template<class T_functor > </td></tr>
+<tr class="memitem:gacbbacd3553268d85b95e3a85aefb67e5"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1hide__functor.html">hide_functor</a><-1, T_functor > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__hide.html#gacbbacd3553268d85b95e3a85aefb67e5">hide</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:gacbbacd3553268d85b95e3a85aefb67e5"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1hide__functor.html" title="Adaptor that adds a dummy parameter to the wrapped functor.">sigc::hide_functor</a> which adds a dummy parameter to the passed functor. <a href="group__hide.html#gacbbacd3553268d85b95e3a85aefb67e5">More...</a><br /></td></tr>
+<tr class="separator:gacbbacd3553268d85b95e3a85aefb67e5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gae4e6f5491471c12440f1c5d480726b98"><td class="memTemplParams" colspan="2">template<class T_functor > </td></tr>
+<tr class="memitem:gae4e6f5491471c12440f1c5d480726b98"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__return__functor.html">retype_return_functor</a>< void, T_functor > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__hide.html#gae4e6f5491471c12440f1c5d480726b98">hide_return</a> (const T_functor & _A_functor)</td></tr>
+<tr class="memdesc:gae4e6f5491471c12440f1c5d480726b98"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__return__functor.html" title="Adaptor that performs a C-style cast on the return value of a functor.">sigc::retype_return_functor</a> which drops the return value of the passed functor. <a href="group__hide.html#gae4e6f5491471c12440f1c5d480726b98">More...</a><br /></td></tr>
+<tr class="separator:gae4e6f5491471c12440f1c5d480726b98"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaeef6e55681664df29b31edec51ea034d"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaeef6e55681664df29b31edec51ea034d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">bound_const_volatile_mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gaeef6e55681664df29b31edec51ea034d">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)() const volatile)</td></tr>
+<tr class="memdesc:gaeef6e55681664df29b31edec51ea034d"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html" title="bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object...">sigc::bound_const_volatile_mem_functor0</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gaeef6e55681664df29b31edec51ea034d">More...</a><br /></td></tr>
+<tr class="separator:gaeef6e55681664df29b31edec51ea034d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaeef6e55681664df29b31edec51ea034d"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaeef6e55681664df29b31edec51ea034d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html">bound_const_mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gaeef6e55681664df29b31edec51ea034d">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)() const)</td></tr>
+<tr class="memdesc:gaeef6e55681664df29b31edec51ea034d"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor0.html" title="bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance.">sigc::bound_const_mem_functor0</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gaeef6e55681664df29b31edec51ea034d">More...</a><br /></td></tr>
+<tr class="separator:gaeef6e55681664df29b31edec51ea034d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaeef6e55681664df29b31edec51ea034d"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaeef6e55681664df29b31edec51ea034d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">bound_volatile_mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gaeef6e55681664df29b31edec51ea034d">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)() volatile)</td></tr>
+<tr class="memdesc:gaeef6e55681664df29b31edec51ea034d"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html" title="bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance.">sigc::bound_volatile_mem_functor0</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gaeef6e55681664df29b31edec51ea034d">More...</a><br /></td></tr>
+<tr class="separator:gaeef6e55681664df29b31edec51ea034d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaeef6e55681664df29b31edec51ea034d"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaeef6e55681664df29b31edec51ea034d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor0.html">bound_mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gaeef6e55681664df29b31edec51ea034d">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)())</td></tr>
+<tr class="memdesc:gaeef6e55681664df29b31edec51ea034d"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor0.html" title="bound_mem_functor0 encapsulates a method with 0 arguments and an object instance.">sigc::bound_mem_functor0</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#gaeef6e55681664df29b31edec51ea034d">More...</a><br /></td></tr>
+<tr class="separator:gaeef6e55681664df29b31edec51ea034d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga7de39a04dfc6d37b2d12a25cdccfbe95"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga7de39a04dfc6d37b2d12a25cdccfbe95"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">bound_const_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga7de39a04dfc6d37b2d12a25cdccfbe95">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1) const volatile)</td></tr>
+<tr class="memdesc:ga7de39a04dfc6d37b2d12a25cdccfbe95"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html" title="bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object...">sigc::bound_const_volatile_mem_functor1</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga7de39a04dfc6d37b2d12a25cdccfbe95">More...</a><br /></td></tr>
+<tr class="separator:ga7de39a04dfc6d37b2d12a25cdccfbe95"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga7de39a04dfc6d37b2d12a25cdccfbe95"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga7de39a04dfc6d37b2d12a25cdccfbe95"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html">bound_const_mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga7de39a04dfc6d37b2d12a25cdccfbe95">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1) const)</td></tr>
+<tr class="memdesc:ga7de39a04dfc6d37b2d12a25cdccfbe95"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor1.html" title="bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance.">sigc::bound_const_mem_functor1</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga7de39a04dfc6d37b2d12a25cdccfbe95">More...</a><br /></td></tr>
+<tr class="separator:ga7de39a04dfc6d37b2d12a25cdccfbe95"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga7de39a04dfc6d37b2d12a25cdccfbe95"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga7de39a04dfc6d37b2d12a25cdccfbe95"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">bound_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga7de39a04dfc6d37b2d12a25cdccfbe95">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1) volatile)</td></tr>
+<tr class="memdesc:ga7de39a04dfc6d37b2d12a25cdccfbe95"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html" title="bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance.">sigc::bound_volatile_mem_functor1</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga7de39a04dfc6d37b2d12a25cdccfbe95">More...</a><br /></td></tr>
+<tr class="separator:ga7de39a04dfc6d37b2d12a25cdccfbe95"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga7de39a04dfc6d37b2d12a25cdccfbe95"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga7de39a04dfc6d37b2d12a25cdccfbe95"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor1.html">bound_mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga7de39a04dfc6d37b2d12a25cdccfbe95">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1))</td></tr>
+<tr class="memdesc:ga7de39a04dfc6d37b2d12a25cdccfbe95"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor1.html" title="bound_mem_functor1 encapsulates a method with 1 arguments and an object instance.">sigc::bound_mem_functor1</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga7de39a04dfc6d37b2d12a25cdccfbe95">More...</a><br /></td></tr>
+<tr class="separator:ga7de39a04dfc6d37b2d12a25cdccfbe95"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gab1add5c927b51b935b4f2d40558079fa"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gab1add5c927b51b935b4f2d40558079fa"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">bound_const_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gab1add5c927b51b935b4f2d40558079fa">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) const volatile)</td></tr>
+<tr class="memdesc:gab1add5c927b51b935b4f2d40558079fa"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html" title="bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object...">sigc::bound_const_volatile_mem_functor2</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gab1add5c927b51b935b4f2d40558079fa">More...</a><br /></td></tr>
+<tr class="separator:gab1add5c927b51b935b4f2d40558079fa"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gab1add5c927b51b935b4f2d40558079fa"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gab1add5c927b51b935b4f2d40558079fa"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html">bound_const_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gab1add5c927b51b935b4f2d40558079fa">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) const)</td></tr>
+<tr class="memdesc:gab1add5c927b51b935b4f2d40558079fa"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor2.html" title="bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance.">sigc::bound_const_mem_functor2</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gab1add5c927b51b935b4f2d40558079fa">More...</a><br /></td></tr>
+<tr class="separator:gab1add5c927b51b935b4f2d40558079fa"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gab1add5c927b51b935b4f2d40558079fa"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gab1add5c927b51b935b4f2d40558079fa"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">bound_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gab1add5c927b51b935b4f2d40558079fa">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) volatile)</td></tr>
+<tr class="memdesc:gab1add5c927b51b935b4f2d40558079fa"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html" title="bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance.">sigc::bound_volatile_mem_functor2</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gab1add5c927b51b935b4f2d40558079fa">More...</a><br /></td></tr>
+<tr class="separator:gab1add5c927b51b935b4f2d40558079fa"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gab1add5c927b51b935b4f2d40558079fa"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gab1add5c927b51b935b4f2d40558079fa"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor2.html">bound_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gab1add5c927b51b935b4f2d40558079fa">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2))</td></tr>
+<tr class="memdesc:gab1add5c927b51b935b4f2d40558079fa"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor2.html" title="bound_mem_functor2 encapsulates a method with 2 arguments and an object instance.">sigc::bound_mem_functor2</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#gab1add5c927b51b935b4f2d40558079fa">More...</a><br /></td></tr>
+<tr class="separator:gab1add5c927b51b935b4f2d40558079fa"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga1f1aa3b60c0d2d8b2470bba0b2b36023"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga1f1aa3b60c0d2d8b2470bba0b2b36023"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">bound_const_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga1f1aa3b60c0d2d8b2470bba0b2b36023">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) const volatile)</td></tr>
+<tr class="memdesc:ga1f1aa3b60c0d2d8b2470bba0b2b36023"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html" title="bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object...">sigc::bound_const_volatile_mem_functor3</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga1f1aa3b60c0d2d8b2470bba0b2b36023">More...</a><br /></td></tr>
+<tr class="separator:ga1f1aa3b60c0d2d8b2470bba0b2b36023"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga1f1aa3b60c0d2d8b2470bba0b2b36023"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga1f1aa3b60c0d2d8b2470bba0b2b36023"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html">bound_const_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga1f1aa3b60c0d2d8b2470bba0b2b36023">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) const)</td></tr>
+<tr class="memdesc:ga1f1aa3b60c0d2d8b2470bba0b2b36023"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor3.html" title="bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance.">sigc::bound_const_mem_functor3</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga1f1aa3b60c0d2d8b2470bba0b2b36023">More...</a><br /></td></tr>
+<tr class="separator:ga1f1aa3b60c0d2d8b2470bba0b2b36023"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga1f1aa3b60c0d2d8b2470bba0b2b36023"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga1f1aa3b60c0d2d8b2470bba0b2b36023"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">bound_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga1f1aa3b60c0d2d8b2470bba0b2b36023">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) volatile)</td></tr>
+<tr class="memdesc:ga1f1aa3b60c0d2d8b2470bba0b2b36023"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html" title="bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance.">sigc::bound_volatile_mem_functor3</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga1f1aa3b60c0d2d8b2470bba0b2b36023">More...</a><br /></td></tr>
+<tr class="separator:ga1f1aa3b60c0d2d8b2470bba0b2b36023"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga1f1aa3b60c0d2d8b2470bba0b2b36023"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga1f1aa3b60c0d2d8b2470bba0b2b36023"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor3.html">bound_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga1f1aa3b60c0d2d8b2470bba0b2b36023">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3))</td></tr>
+<tr class="memdesc:ga1f1aa3b60c0d2d8b2470bba0b2b36023"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor3.html" title="bound_mem_functor3 encapsulates a method with 3 arguments and an object instance.">sigc::bound_mem_functor3</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga1f1aa3b60c0d2d8b2470bba0b2b36023">More...</a><br /></td></tr>
+<tr class="separator:ga1f1aa3b60c0d2d8b2470bba0b2b36023"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga481ef34d8423d26e8ff0a1916cd295d5"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga481ef34d8423d26e8ff0a1916cd295d5"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">bound_const_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga481ef34d8423d26e8ff0a1916cd295d5">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)</td></tr>
+<tr class="memdesc:ga481ef34d8423d26e8ff0a1916cd295d5"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html" title="bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object...">sigc::bound_const_volatile_mem_functor4</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga481ef34d8423d26e8ff0a1916cd295d5">More...</a><br /></td></tr>
+<tr class="separator:ga481ef34d8423d26e8ff0a1916cd295d5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga481ef34d8423d26e8ff0a1916cd295d5"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga481ef34d8423d26e8ff0a1916cd295d5"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html">bound_const_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga481ef34d8423d26e8ff0a1916cd295d5">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)</td></tr>
+<tr class="memdesc:ga481ef34d8423d26e8ff0a1916cd295d5"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor4.html" title="bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance.">sigc::bound_const_mem_functor4</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga481ef34d8423d26e8ff0a1916cd295d5">More...</a><br /></td></tr>
+<tr class="separator:ga481ef34d8423d26e8ff0a1916cd295d5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga481ef34d8423d26e8ff0a1916cd295d5"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga481ef34d8423d26e8ff0a1916cd295d5"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">bound_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga481ef34d8423d26e8ff0a1916cd295d5">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)</td></tr>
+<tr class="memdesc:ga481ef34d8423d26e8ff0a1916cd295d5"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html" title="bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance.">sigc::bound_volatile_mem_functor4</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga481ef34d8423d26e8ff0a1916cd295d5">More...</a><br /></td></tr>
+<tr class="separator:ga481ef34d8423d26e8ff0a1916cd295d5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga481ef34d8423d26e8ff0a1916cd295d5"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga481ef34d8423d26e8ff0a1916cd295d5"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor4.html">bound_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga481ef34d8423d26e8ff0a1916cd295d5">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</td></tr>
+<tr class="memdesc:ga481ef34d8423d26e8ff0a1916cd295d5"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor4.html" title="bound_mem_functor4 encapsulates a method with 4 arguments and an object instance.">sigc::bound_mem_functor4</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga481ef34d8423d26e8ff0a1916cd295d5">More...</a><br /></td></tr>
+<tr class="separator:ga481ef34d8423d26e8ff0a1916cd295d5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga09fb13b1684ec7c092ffef695dbb261a"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga09fb13b1684ec7c092ffef695dbb261a"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">bound_const_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga09fb13b1684ec7c092ffef695dbb261a">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)</td></tr>
+<tr class="memdesc:ga09fb13b1684ec7c092ffef695dbb261a"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html" title="bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object...">sigc::bound_const_volatile_mem_functor5</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga09fb13b1684ec7c092ffef695dbb261a">More...</a><br /></td></tr>
+<tr class="separator:ga09fb13b1684ec7c092ffef695dbb261a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga09fb13b1684ec7c092ffef695dbb261a"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga09fb13b1684ec7c092ffef695dbb261a"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html">bound_const_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga09fb13b1684ec7c092ffef695dbb261a">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)</td></tr>
+<tr class="memdesc:ga09fb13b1684ec7c092ffef695dbb261a"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor5.html" title="bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance.">sigc::bound_const_mem_functor5</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga09fb13b1684ec7c092ffef695dbb261a">More...</a><br /></td></tr>
+<tr class="separator:ga09fb13b1684ec7c092ffef695dbb261a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga09fb13b1684ec7c092ffef695dbb261a"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga09fb13b1684ec7c092ffef695dbb261a"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">bound_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga09fb13b1684ec7c092ffef695dbb261a">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)</td></tr>
+<tr class="memdesc:ga09fb13b1684ec7c092ffef695dbb261a"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html" title="bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance.">sigc::bound_volatile_mem_functor5</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga09fb13b1684ec7c092ffef695dbb261a">More...</a><br /></td></tr>
+<tr class="separator:ga09fb13b1684ec7c092ffef695dbb261a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga09fb13b1684ec7c092ffef695dbb261a"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga09fb13b1684ec7c092ffef695dbb261a"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor5.html">bound_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga09fb13b1684ec7c092ffef695dbb261a">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</td></tr>
+<tr class="memdesc:ga09fb13b1684ec7c092ffef695dbb261a"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor5.html" title="bound_mem_functor5 encapsulates a method with 5 arguments and an object instance.">sigc::bound_mem_functor5</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga09fb13b1684ec7c092ffef695dbb261a">More...</a><br /></td></tr>
+<tr class="separator:ga09fb13b1684ec7c092ffef695dbb261a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga0d9b992d69123a524b6c70c458ad0d40"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga0d9b992d69123a524b6c70c458ad0d40"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">bound_const_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga0d9b992d69123a524b6c70c458ad0d40">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)</td></tr>
+<tr class="memdesc:ga0d9b992d69123a524b6c70c458ad0d40"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html" title="bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object...">sigc::bound_const_volatile_mem_functor6</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga0d9b992d69123a524b6c70c458ad0d40">More...</a><br /></td></tr>
+<tr class="separator:ga0d9b992d69123a524b6c70c458ad0d40"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga0d9b992d69123a524b6c70c458ad0d40"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga0d9b992d69123a524b6c70c458ad0d40"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html">bound_const_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga0d9b992d69123a524b6c70c458ad0d40">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)</td></tr>
+<tr class="memdesc:ga0d9b992d69123a524b6c70c458ad0d40"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor6.html" title="bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance.">sigc::bound_const_mem_functor6</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga0d9b992d69123a524b6c70c458ad0d40">More...</a><br /></td></tr>
+<tr class="separator:ga0d9b992d69123a524b6c70c458ad0d40"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga0d9b992d69123a524b6c70c458ad0d40"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga0d9b992d69123a524b6c70c458ad0d40"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">bound_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga0d9b992d69123a524b6c70c458ad0d40">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)</td></tr>
+<tr class="memdesc:ga0d9b992d69123a524b6c70c458ad0d40"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html" title="bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance.">sigc::bound_volatile_mem_functor6</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga0d9b992d69123a524b6c70c458ad0d40">More...</a><br /></td></tr>
+<tr class="separator:ga0d9b992d69123a524b6c70c458ad0d40"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga0d9b992d69123a524b6c70c458ad0d40"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga0d9b992d69123a524b6c70c458ad0d40"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor6.html">bound_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga0d9b992d69123a524b6c70c458ad0d40">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</td></tr>
+<tr class="memdesc:ga0d9b992d69123a524b6c70c458ad0d40"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor6.html" title="bound_mem_functor6 encapsulates a method with 6 arguments and an object instance.">sigc::bound_mem_functor6</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga0d9b992d69123a524b6c70c458ad0d40">More...</a><br /></td></tr>
+<tr class="separator:ga0d9b992d69123a524b6c70c458ad0d40"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga5dcdaf235baa50049e6088d246853037"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga5dcdaf235baa50049e6088d246853037"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">bound_const_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga5dcdaf235baa50049e6088d246853037">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)</td></tr>
+<tr class="memdesc:ga5dcdaf235baa50049e6088d246853037"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html" title="bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object...">sigc::bound_const_volatile_mem_functor7</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga5dcdaf235baa50049e6088d246853037">More...</a><br /></td></tr>
+<tr class="separator:ga5dcdaf235baa50049e6088d246853037"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga5dcdaf235baa50049e6088d246853037"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga5dcdaf235baa50049e6088d246853037"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html">bound_const_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga5dcdaf235baa50049e6088d246853037">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)</td></tr>
+<tr class="memdesc:ga5dcdaf235baa50049e6088d246853037"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor7.html" title="bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance.">sigc::bound_const_mem_functor7</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga5dcdaf235baa50049e6088d246853037">More...</a><br /></td></tr>
+<tr class="separator:ga5dcdaf235baa50049e6088d246853037"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga5dcdaf235baa50049e6088d246853037"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga5dcdaf235baa50049e6088d246853037"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">bound_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga5dcdaf235baa50049e6088d246853037">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)</td></tr>
+<tr class="memdesc:ga5dcdaf235baa50049e6088d246853037"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html" title="bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance.">sigc::bound_volatile_mem_functor7</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga5dcdaf235baa50049e6088d246853037">More...</a><br /></td></tr>
+<tr class="separator:ga5dcdaf235baa50049e6088d246853037"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga5dcdaf235baa50049e6088d246853037"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga5dcdaf235baa50049e6088d246853037"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor7.html">bound_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga5dcdaf235baa50049e6088d246853037">mem_fun</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</td></tr>
+<tr class="memdesc:ga5dcdaf235baa50049e6088d246853037"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor7.html" title="bound_mem_functor7 encapsulates a method with 7 arguments and an object instance.">sigc::bound_mem_functor7</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga5dcdaf235baa50049e6088d246853037">More...</a><br /></td></tr>
+<tr class="separator:ga5dcdaf235baa50049e6088d246853037"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga7f57ec0156d33b4aa98e259d2e2062db"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga7f57ec0156d33b4aa98e259d2e2062db"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">bound_const_volatile_mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga7f57ec0156d33b4aa98e259d2e2062db">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)() const volatile)</td></tr>
+<tr class="memdesc:ga7f57ec0156d33b4aa98e259d2e2062db"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html" title="bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object...">sigc::bound_const_volatile_mem_functor0</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga7f57ec0156d33b4aa98e259d2e2062db">More...</a><br /></td></tr>
+<tr class="separator:ga7f57ec0156d33b4aa98e259d2e2062db"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga7f57ec0156d33b4aa98e259d2e2062db"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga7f57ec0156d33b4aa98e259d2e2062db"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html">bound_const_mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga7f57ec0156d33b4aa98e259d2e2062db">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)() const)</td></tr>
+<tr class="memdesc:ga7f57ec0156d33b4aa98e259d2e2062db"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor0.html" title="bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance.">sigc::bound_const_mem_functor0</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga7f57ec0156d33b4aa98e259d2e2062db">More...</a><br /></td></tr>
+<tr class="separator:ga7f57ec0156d33b4aa98e259d2e2062db"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga7f57ec0156d33b4aa98e259d2e2062db"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga7f57ec0156d33b4aa98e259d2e2062db"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">bound_volatile_mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga7f57ec0156d33b4aa98e259d2e2062db">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)() volatile)</td></tr>
+<tr class="memdesc:ga7f57ec0156d33b4aa98e259d2e2062db"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html" title="bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance.">sigc::bound_volatile_mem_functor0</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga7f57ec0156d33b4aa98e259d2e2062db">More...</a><br /></td></tr>
+<tr class="separator:ga7f57ec0156d33b4aa98e259d2e2062db"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga7f57ec0156d33b4aa98e259d2e2062db"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga7f57ec0156d33b4aa98e259d2e2062db"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor0.html">bound_mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga7f57ec0156d33b4aa98e259d2e2062db">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)())</td></tr>
+<tr class="memdesc:ga7f57ec0156d33b4aa98e259d2e2062db"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor0.html" title="bound_mem_functor0 encapsulates a method with 0 arguments and an object instance.">sigc::bound_mem_functor0</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga7f57ec0156d33b4aa98e259d2e2062db">More...</a><br /></td></tr>
+<tr class="separator:ga7f57ec0156d33b4aa98e259d2e2062db"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga0df7af9f32990cc624c4bb60782b4f78"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga0df7af9f32990cc624c4bb60782b4f78"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">bound_const_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga0df7af9f32990cc624c4bb60782b4f78">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1) const volatile)</td></tr>
+<tr class="memdesc:ga0df7af9f32990cc624c4bb60782b4f78"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html" title="bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object...">sigc::bound_const_volatile_mem_functor1</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga0df7af9f32990cc624c4bb60782b4f78">More...</a><br /></td></tr>
+<tr class="separator:ga0df7af9f32990cc624c4bb60782b4f78"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga0df7af9f32990cc624c4bb60782b4f78"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga0df7af9f32990cc624c4bb60782b4f78"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html">bound_const_mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga0df7af9f32990cc624c4bb60782b4f78">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1) const)</td></tr>
+<tr class="memdesc:ga0df7af9f32990cc624c4bb60782b4f78"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor1.html" title="bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance.">sigc::bound_const_mem_functor1</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga0df7af9f32990cc624c4bb60782b4f78">More...</a><br /></td></tr>
+<tr class="separator:ga0df7af9f32990cc624c4bb60782b4f78"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga0df7af9f32990cc624c4bb60782b4f78"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga0df7af9f32990cc624c4bb60782b4f78"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">bound_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga0df7af9f32990cc624c4bb60782b4f78">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1) volatile)</td></tr>
+<tr class="memdesc:ga0df7af9f32990cc624c4bb60782b4f78"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html" title="bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance.">sigc::bound_volatile_mem_functor1</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga0df7af9f32990cc624c4bb60782b4f78">More...</a><br /></td></tr>
+<tr class="separator:ga0df7af9f32990cc624c4bb60782b4f78"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga0df7af9f32990cc624c4bb60782b4f78"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga0df7af9f32990cc624c4bb60782b4f78"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor1.html">bound_mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga0df7af9f32990cc624c4bb60782b4f78">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1))</td></tr>
+<tr class="memdesc:ga0df7af9f32990cc624c4bb60782b4f78"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor1.html" title="bound_mem_functor1 encapsulates a method with 1 arguments and an object instance.">sigc::bound_mem_functor1</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga0df7af9f32990cc624c4bb60782b4f78">More...</a><br /></td></tr>
+<tr class="separator:ga0df7af9f32990cc624c4bb60782b4f78"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga118b2610268701be95cdc6fddb7bab3b"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga118b2610268701be95cdc6fddb7bab3b"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">bound_const_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga118b2610268701be95cdc6fddb7bab3b">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) const volatile)</td></tr>
+<tr class="memdesc:ga118b2610268701be95cdc6fddb7bab3b"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html" title="bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object...">sigc::bound_const_volatile_mem_functor2</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga118b2610268701be95cdc6fddb7bab3b">More...</a><br /></td></tr>
+<tr class="separator:ga118b2610268701be95cdc6fddb7bab3b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga118b2610268701be95cdc6fddb7bab3b"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga118b2610268701be95cdc6fddb7bab3b"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html">bound_const_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga118b2610268701be95cdc6fddb7bab3b">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) const)</td></tr>
+<tr class="memdesc:ga118b2610268701be95cdc6fddb7bab3b"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor2.html" title="bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance.">sigc::bound_const_mem_functor2</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga118b2610268701be95cdc6fddb7bab3b">More...</a><br /></td></tr>
+<tr class="separator:ga118b2610268701be95cdc6fddb7bab3b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga118b2610268701be95cdc6fddb7bab3b"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga118b2610268701be95cdc6fddb7bab3b"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">bound_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga118b2610268701be95cdc6fddb7bab3b">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) volatile)</td></tr>
+<tr class="memdesc:ga118b2610268701be95cdc6fddb7bab3b"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html" title="bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance.">sigc::bound_volatile_mem_functor2</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga118b2610268701be95cdc6fddb7bab3b">More...</a><br /></td></tr>
+<tr class="separator:ga118b2610268701be95cdc6fddb7bab3b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga118b2610268701be95cdc6fddb7bab3b"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga118b2610268701be95cdc6fddb7bab3b"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor2.html">bound_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga118b2610268701be95cdc6fddb7bab3b">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2))</td></tr>
+<tr class="memdesc:ga118b2610268701be95cdc6fddb7bab3b"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor2.html" title="bound_mem_functor2 encapsulates a method with 2 arguments and an object instance.">sigc::bound_mem_functor2</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga118b2610268701be95cdc6fddb7bab3b">More...</a><br /></td></tr>
+<tr class="separator:ga118b2610268701be95cdc6fddb7bab3b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaeb6bd4518e0f0c524dba13a6cbb2e319"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaeb6bd4518e0f0c524dba13a6cbb2e319"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">bound_const_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gaeb6bd4518e0f0c524dba13a6cbb2e319">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) const volatile)</td></tr>
+<tr class="memdesc:gaeb6bd4518e0f0c524dba13a6cbb2e319"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html" title="bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object...">sigc::bound_const_volatile_mem_functor3</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gaeb6bd4518e0f0c524dba13a6cbb2e319">More...</a><br /></td></tr>
+<tr class="separator:gaeb6bd4518e0f0c524dba13a6cbb2e319"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaeb6bd4518e0f0c524dba13a6cbb2e319"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaeb6bd4518e0f0c524dba13a6cbb2e319"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html">bound_const_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gaeb6bd4518e0f0c524dba13a6cbb2e319">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) const)</td></tr>
+<tr class="memdesc:gaeb6bd4518e0f0c524dba13a6cbb2e319"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor3.html" title="bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance.">sigc::bound_const_mem_functor3</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gaeb6bd4518e0f0c524dba13a6cbb2e319">More...</a><br /></td></tr>
+<tr class="separator:gaeb6bd4518e0f0c524dba13a6cbb2e319"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaeb6bd4518e0f0c524dba13a6cbb2e319"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaeb6bd4518e0f0c524dba13a6cbb2e319"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">bound_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gaeb6bd4518e0f0c524dba13a6cbb2e319">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) volatile)</td></tr>
+<tr class="memdesc:gaeb6bd4518e0f0c524dba13a6cbb2e319"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html" title="bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance.">sigc::bound_volatile_mem_functor3</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gaeb6bd4518e0f0c524dba13a6cbb2e319">More...</a><br /></td></tr>
+<tr class="separator:gaeb6bd4518e0f0c524dba13a6cbb2e319"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaeb6bd4518e0f0c524dba13a6cbb2e319"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaeb6bd4518e0f0c524dba13a6cbb2e319"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor3.html">bound_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gaeb6bd4518e0f0c524dba13a6cbb2e319">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3))</td></tr>
+<tr class="memdesc:gaeb6bd4518e0f0c524dba13a6cbb2e319"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor3.html" title="bound_mem_functor3 encapsulates a method with 3 arguments and an object instance.">sigc::bound_mem_functor3</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#gaeb6bd4518e0f0c524dba13a6cbb2e319">More...</a><br /></td></tr>
+<tr class="separator:gaeb6bd4518e0f0c524dba13a6cbb2e319"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga02c906c95895c58e39ee301bb1577994"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga02c906c95895c58e39ee301bb1577994"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">bound_const_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga02c906c95895c58e39ee301bb1577994">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)</td></tr>
+<tr class="memdesc:ga02c906c95895c58e39ee301bb1577994"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html" title="bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object...">sigc::bound_const_volatile_mem_functor4</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga02c906c95895c58e39ee301bb1577994">More...</a><br /></td></tr>
+<tr class="separator:ga02c906c95895c58e39ee301bb1577994"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga02c906c95895c58e39ee301bb1577994"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga02c906c95895c58e39ee301bb1577994"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html">bound_const_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga02c906c95895c58e39ee301bb1577994">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)</td></tr>
+<tr class="memdesc:ga02c906c95895c58e39ee301bb1577994"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor4.html" title="bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance.">sigc::bound_const_mem_functor4</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga02c906c95895c58e39ee301bb1577994">More...</a><br /></td></tr>
+<tr class="separator:ga02c906c95895c58e39ee301bb1577994"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga02c906c95895c58e39ee301bb1577994"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga02c906c95895c58e39ee301bb1577994"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">bound_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga02c906c95895c58e39ee301bb1577994">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)</td></tr>
+<tr class="memdesc:ga02c906c95895c58e39ee301bb1577994"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html" title="bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance.">sigc::bound_volatile_mem_functor4</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga02c906c95895c58e39ee301bb1577994">More...</a><br /></td></tr>
+<tr class="separator:ga02c906c95895c58e39ee301bb1577994"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga02c906c95895c58e39ee301bb1577994"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga02c906c95895c58e39ee301bb1577994"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor4.html">bound_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga02c906c95895c58e39ee301bb1577994">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</td></tr>
+<tr class="memdesc:ga02c906c95895c58e39ee301bb1577994"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor4.html" title="bound_mem_functor4 encapsulates a method with 4 arguments and an object instance.">sigc::bound_mem_functor4</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga02c906c95895c58e39ee301bb1577994">More...</a><br /></td></tr>
+<tr class="separator:ga02c906c95895c58e39ee301bb1577994"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gab138ae1a340be983166b69872826b37d"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gab138ae1a340be983166b69872826b37d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">bound_const_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gab138ae1a340be983166b69872826b37d">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)</td></tr>
+<tr class="memdesc:gab138ae1a340be983166b69872826b37d"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html" title="bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object...">sigc::bound_const_volatile_mem_functor5</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gab138ae1a340be983166b69872826b37d">More...</a><br /></td></tr>
+<tr class="separator:gab138ae1a340be983166b69872826b37d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gab138ae1a340be983166b69872826b37d"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gab138ae1a340be983166b69872826b37d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html">bound_const_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gab138ae1a340be983166b69872826b37d">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)</td></tr>
+<tr class="memdesc:gab138ae1a340be983166b69872826b37d"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor5.html" title="bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance.">sigc::bound_const_mem_functor5</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gab138ae1a340be983166b69872826b37d">More...</a><br /></td></tr>
+<tr class="separator:gab138ae1a340be983166b69872826b37d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gab138ae1a340be983166b69872826b37d"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gab138ae1a340be983166b69872826b37d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">bound_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gab138ae1a340be983166b69872826b37d">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)</td></tr>
+<tr class="memdesc:gab138ae1a340be983166b69872826b37d"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html" title="bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance.">sigc::bound_volatile_mem_functor5</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gab138ae1a340be983166b69872826b37d">More...</a><br /></td></tr>
+<tr class="separator:gab138ae1a340be983166b69872826b37d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gab138ae1a340be983166b69872826b37d"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gab138ae1a340be983166b69872826b37d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor5.html">bound_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gab138ae1a340be983166b69872826b37d">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</td></tr>
+<tr class="memdesc:gab138ae1a340be983166b69872826b37d"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor5.html" title="bound_mem_functor5 encapsulates a method with 5 arguments and an object instance.">sigc::bound_mem_functor5</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#gab138ae1a340be983166b69872826b37d">More...</a><br /></td></tr>
+<tr class="separator:gab138ae1a340be983166b69872826b37d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga3e3841c4844715d2f2d832ed506f028f"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga3e3841c4844715d2f2d832ed506f028f"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">bound_const_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga3e3841c4844715d2f2d832ed506f028f">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)</td></tr>
+<tr class="memdesc:ga3e3841c4844715d2f2d832ed506f028f"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html" title="bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object...">sigc::bound_const_volatile_mem_functor6</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga3e3841c4844715d2f2d832ed506f028f">More...</a><br /></td></tr>
+<tr class="separator:ga3e3841c4844715d2f2d832ed506f028f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga3e3841c4844715d2f2d832ed506f028f"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga3e3841c4844715d2f2d832ed506f028f"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html">bound_const_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga3e3841c4844715d2f2d832ed506f028f">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)</td></tr>
+<tr class="memdesc:ga3e3841c4844715d2f2d832ed506f028f"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor6.html" title="bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance.">sigc::bound_const_mem_functor6</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga3e3841c4844715d2f2d832ed506f028f">More...</a><br /></td></tr>
+<tr class="separator:ga3e3841c4844715d2f2d832ed506f028f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga3e3841c4844715d2f2d832ed506f028f"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga3e3841c4844715d2f2d832ed506f028f"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">bound_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga3e3841c4844715d2f2d832ed506f028f">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)</td></tr>
+<tr class="memdesc:ga3e3841c4844715d2f2d832ed506f028f"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html" title="bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance.">sigc::bound_volatile_mem_functor6</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga3e3841c4844715d2f2d832ed506f028f">More...</a><br /></td></tr>
+<tr class="separator:ga3e3841c4844715d2f2d832ed506f028f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga3e3841c4844715d2f2d832ed506f028f"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga3e3841c4844715d2f2d832ed506f028f"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor6.html">bound_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga3e3841c4844715d2f2d832ed506f028f">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</td></tr>
+<tr class="memdesc:ga3e3841c4844715d2f2d832ed506f028f"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor6.html" title="bound_mem_functor6 encapsulates a method with 6 arguments and an object instance.">sigc::bound_mem_functor6</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga3e3841c4844715d2f2d832ed506f028f">More...</a><br /></td></tr>
+<tr class="separator:ga3e3841c4844715d2f2d832ed506f028f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaea5a2ace2699b8d1ffe93585e335548d"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaea5a2ace2699b8d1ffe93585e335548d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">bound_const_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gaea5a2ace2699b8d1ffe93585e335548d">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)</td></tr>
+<tr class="memdesc:gaea5a2ace2699b8d1ffe93585e335548d"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html" title="bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object...">sigc::bound_const_volatile_mem_functor7</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gaea5a2ace2699b8d1ffe93585e335548d">More...</a><br /></td></tr>
+<tr class="separator:gaea5a2ace2699b8d1ffe93585e335548d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaea5a2ace2699b8d1ffe93585e335548d"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaea5a2ace2699b8d1ffe93585e335548d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html">bound_const_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gaea5a2ace2699b8d1ffe93585e335548d">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)</td></tr>
+<tr class="memdesc:gaea5a2ace2699b8d1ffe93585e335548d"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor7.html" title="bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance.">sigc::bound_const_mem_functor7</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gaea5a2ace2699b8d1ffe93585e335548d">More...</a><br /></td></tr>
+<tr class="separator:gaea5a2ace2699b8d1ffe93585e335548d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaea5a2ace2699b8d1ffe93585e335548d"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaea5a2ace2699b8d1ffe93585e335548d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">bound_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gaea5a2ace2699b8d1ffe93585e335548d">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)</td></tr>
+<tr class="memdesc:gaea5a2ace2699b8d1ffe93585e335548d"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html" title="bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance.">sigc::bound_volatile_mem_functor7</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gaea5a2ace2699b8d1ffe93585e335548d">More...</a><br /></td></tr>
+<tr class="separator:gaea5a2ace2699b8d1ffe93585e335548d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaea5a2ace2699b8d1ffe93585e335548d"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaea5a2ace2699b8d1ffe93585e335548d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor7.html">bound_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gaea5a2ace2699b8d1ffe93585e335548d">mem_fun</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</td></tr>
+<tr class="memdesc:gaea5a2ace2699b8d1ffe93585e335548d"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor7.html" title="bound_mem_functor7 encapsulates a method with 7 arguments and an object instance.">sigc::bound_mem_functor7</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#gaea5a2ace2699b8d1ffe93585e335548d">More...</a><br /></td></tr>
+<tr class="separator:gaea5a2ace2699b8d1ffe93585e335548d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gadf6b6d22c503b439019f0a2e77352419"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj > </td></tr>
+<tr class="memitem:gadf6b6d22c503b439019f0a2e77352419"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">const_volatile_mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gadf6b6d22c503b439019f0a2e77352419">mem_fun</a> (T_return(T_obj::* _A_func)() const volatile)</td></tr>
+<tr class="memdesc:gadf6b6d22c503b439019f0a2e77352419"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html" title="const_volatile_mem_functor0 wraps const volatile methods with 0 argument(s).">sigc::const_volatile_mem_functor0</a> which wraps a const volatile method. <a href="namespacesigc.html#gadf6b6d22c503b439019f0a2e77352419">More...</a><br /></td></tr>
+<tr class="separator:gadf6b6d22c503b439019f0a2e77352419"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gadf6b6d22c503b439019f0a2e77352419"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj > </td></tr>
+<tr class="memitem:gadf6b6d22c503b439019f0a2e77352419"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor0.html">const_mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gadf6b6d22c503b439019f0a2e77352419">mem_fun</a> (T_return(T_obj::* _A_func)() const)</td></tr>
+<tr class="memdesc:gadf6b6d22c503b439019f0a2e77352419"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor0.html" title="const_mem_functor0 wraps const methods with 0 argument(s).">sigc::const_mem_functor0</a> which wraps a const method. <a href="namespacesigc.html#gadf6b6d22c503b439019f0a2e77352419">More...</a><br /></td></tr>
+<tr class="separator:gadf6b6d22c503b439019f0a2e77352419"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gadf6b6d22c503b439019f0a2e77352419"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj > </td></tr>
+<tr class="memitem:gadf6b6d22c503b439019f0a2e77352419"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor0.html">volatile_mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gadf6b6d22c503b439019f0a2e77352419">mem_fun</a> (T_return(T_obj::* _A_func)() volatile)</td></tr>
+<tr class="memdesc:gadf6b6d22c503b439019f0a2e77352419"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor0.html" title="volatile_mem_functor0 wraps volatile methods with 0 argument(s).">sigc::volatile_mem_functor0</a> which wraps a volatile method. <a href="namespacesigc.html#gadf6b6d22c503b439019f0a2e77352419">More...</a><br /></td></tr>
+<tr class="separator:gadf6b6d22c503b439019f0a2e77352419"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gadf6b6d22c503b439019f0a2e77352419"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj > </td></tr>
+<tr class="memitem:gadf6b6d22c503b439019f0a2e77352419"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor0.html">mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">mem_fun</a> (T_return(T_obj::* _A_func)())</td></tr>
+<tr class="memdesc:gadf6b6d22c503b439019f0a2e77352419"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor0.html" title="mem_functor0 wraps methods with 0 argument(s).">sigc::mem_functor0</a> which wraps a method. <a href="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419">More...</a><br /></td></tr>
+<tr class="separator:gadf6b6d22c503b439019f0a2e77352419"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gab661fef0f04e2e439912eee6989e9657"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gab661fef0f04e2e439912eee6989e9657"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">const_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gab661fef0f04e2e439912eee6989e9657">mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1) const volatile)</td></tr>
+<tr class="memdesc:gab661fef0f04e2e439912eee6989e9657"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html" title="const_volatile_mem_functor1 wraps const volatile methods with 1 argument(s).">sigc::const_volatile_mem_functor1</a> which wraps a const volatile method. <a href="namespacesigc.html#gab661fef0f04e2e439912eee6989e9657">More...</a><br /></td></tr>
+<tr class="separator:gab661fef0f04e2e439912eee6989e9657"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gab661fef0f04e2e439912eee6989e9657"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gab661fef0f04e2e439912eee6989e9657"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor1.html">const_mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gab661fef0f04e2e439912eee6989e9657">mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1) const)</td></tr>
+<tr class="memdesc:gab661fef0f04e2e439912eee6989e9657"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor1.html" title="const_mem_functor1 wraps const methods with 1 argument(s).">sigc::const_mem_functor1</a> which wraps a const method. <a href="namespacesigc.html#gab661fef0f04e2e439912eee6989e9657">More...</a><br /></td></tr>
+<tr class="separator:gab661fef0f04e2e439912eee6989e9657"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gab661fef0f04e2e439912eee6989e9657"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gab661fef0f04e2e439912eee6989e9657"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor1.html">volatile_mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gab661fef0f04e2e439912eee6989e9657">mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1) volatile)</td></tr>
+<tr class="memdesc:gab661fef0f04e2e439912eee6989e9657"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor1.html" title="volatile_mem_functor1 wraps volatile methods with 1 argument(s).">sigc::volatile_mem_functor1</a> which wraps a volatile method. <a href="namespacesigc.html#gab661fef0f04e2e439912eee6989e9657">More...</a><br /></td></tr>
+<tr class="separator:gab661fef0f04e2e439912eee6989e9657"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gab661fef0f04e2e439912eee6989e9657"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gab661fef0f04e2e439912eee6989e9657"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor1.html">mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gab661fef0f04e2e439912eee6989e9657">mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1))</td></tr>
+<tr class="memdesc:gab661fef0f04e2e439912eee6989e9657"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor1.html" title="mem_functor1 wraps methods with 1 argument(s).">sigc::mem_functor1</a> which wraps a method. <a href="group__mem__fun.html#gab661fef0f04e2e439912eee6989e9657">More...</a><br /></td></tr>
+<tr class="separator:gab661fef0f04e2e439912eee6989e9657"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">const_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5">mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2) const volatile)</td></tr>
+<tr class="memdesc:ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html" title="const_volatile_mem_functor2 wraps const volatile methods with 2 argument(s).">sigc::const_volatile_mem_functor2</a> which wraps a const volatile method. <a href="namespacesigc.html#ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5">More...</a><br /></td></tr>
+<tr class="separator:ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor2.html">const_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5">mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2) const)</td></tr>
+<tr class="memdesc:ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor2.html" title="const_mem_functor2 wraps const methods with 2 argument(s).">sigc::const_mem_functor2</a> which wraps a const method. <a href="namespacesigc.html#ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5">More...</a><br /></td></tr>
+<tr class="separator:ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor2.html">volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5">mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2) volatile)</td></tr>
+<tr class="memdesc:ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor2.html" title="volatile_mem_functor2 wraps volatile methods with 2 argument(s).">sigc::volatile_mem_functor2</a> which wraps a volatile method. <a href="namespacesigc.html#ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5">More...</a><br /></td></tr>
+<tr class="separator:ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor2.html">mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5">mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2))</td></tr>
+<tr class="memdesc:ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor2.html" title="mem_functor2 wraps methods with 2 argument(s).">sigc::mem_functor2</a> which wraps a method. <a href="group__mem__fun.html#ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5">More...</a><br /></td></tr>
+<tr class="separator:ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaa3778234963fa65d4f638856d91109d1"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gaa3778234963fa65d4f638856d91109d1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">const_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gaa3778234963fa65d4f638856d91109d1">mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3) const volatile)</td></tr>
+<tr class="memdesc:gaa3778234963fa65d4f638856d91109d1"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html" title="const_volatile_mem_functor3 wraps const volatile methods with 3 argument(s).">sigc::const_volatile_mem_functor3</a> which wraps a const volatile method. <a href="namespacesigc.html#gaa3778234963fa65d4f638856d91109d1">More...</a><br /></td></tr>
+<tr class="separator:gaa3778234963fa65d4f638856d91109d1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaa3778234963fa65d4f638856d91109d1"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gaa3778234963fa65d4f638856d91109d1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor3.html">const_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gaa3778234963fa65d4f638856d91109d1">mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3) const)</td></tr>
+<tr class="memdesc:gaa3778234963fa65d4f638856d91109d1"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor3.html" title="const_mem_functor3 wraps const methods with 3 argument(s).">sigc::const_mem_functor3</a> which wraps a const method. <a href="namespacesigc.html#gaa3778234963fa65d4f638856d91109d1">More...</a><br /></td></tr>
+<tr class="separator:gaa3778234963fa65d4f638856d91109d1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaa3778234963fa65d4f638856d91109d1"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gaa3778234963fa65d4f638856d91109d1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor3.html">volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gaa3778234963fa65d4f638856d91109d1">mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3) volatile)</td></tr>
+<tr class="memdesc:gaa3778234963fa65d4f638856d91109d1"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor3.html" title="volatile_mem_functor3 wraps volatile methods with 3 argument(s).">sigc::volatile_mem_functor3</a> which wraps a volatile method. <a href="namespacesigc.html#gaa3778234963fa65d4f638856d91109d1">More...</a><br /></td></tr>
+<tr class="separator:gaa3778234963fa65d4f638856d91109d1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaa3778234963fa65d4f638856d91109d1"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gaa3778234963fa65d4f638856d91109d1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor3.html">mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gaa3778234963fa65d4f638856d91109d1">mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3))</td></tr>
+<tr class="memdesc:gaa3778234963fa65d4f638856d91109d1"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor3.html" title="mem_functor3 wraps methods with 3 argument(s).">sigc::mem_functor3</a> which wraps a method. <a href="group__mem__fun.html#gaa3778234963fa65d4f638856d91109d1">More...</a><br /></td></tr>
+<tr class="separator:gaa3778234963fa65d4f638856d91109d1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gadadd40aba6dadd0edbaac609dfae3938"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gadadd40aba6dadd0edbaac609dfae3938"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">const_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gadadd40aba6dadd0edbaac609dfae3938">mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)</td></tr>
+<tr class="memdesc:gadadd40aba6dadd0edbaac609dfae3938"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html" title="const_volatile_mem_functor4 wraps const volatile methods with 4 argument(s).">sigc::const_volatile_mem_functor4</a> which wraps a const volatile method. <a href="namespacesigc.html#gadadd40aba6dadd0edbaac609dfae3938">More...</a><br /></td></tr>
+<tr class="separator:gadadd40aba6dadd0edbaac609dfae3938"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gadadd40aba6dadd0edbaac609dfae3938"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gadadd40aba6dadd0edbaac609dfae3938"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor4.html">const_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gadadd40aba6dadd0edbaac609dfae3938">mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)</td></tr>
+<tr class="memdesc:gadadd40aba6dadd0edbaac609dfae3938"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor4.html" title="const_mem_functor4 wraps const methods with 4 argument(s).">sigc::const_mem_functor4</a> which wraps a const method. <a href="namespacesigc.html#gadadd40aba6dadd0edbaac609dfae3938">More...</a><br /></td></tr>
+<tr class="separator:gadadd40aba6dadd0edbaac609dfae3938"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gadadd40aba6dadd0edbaac609dfae3938"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gadadd40aba6dadd0edbaac609dfae3938"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor4.html">volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gadadd40aba6dadd0edbaac609dfae3938">mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)</td></tr>
+<tr class="memdesc:gadadd40aba6dadd0edbaac609dfae3938"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor4.html" title="volatile_mem_functor4 wraps volatile methods with 4 argument(s).">sigc::volatile_mem_functor4</a> which wraps a volatile method. <a href="namespacesigc.html#gadadd40aba6dadd0edbaac609dfae3938">More...</a><br /></td></tr>
+<tr class="separator:gadadd40aba6dadd0edbaac609dfae3938"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gadadd40aba6dadd0edbaac609dfae3938"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gadadd40aba6dadd0edbaac609dfae3938"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor4.html">mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gadadd40aba6dadd0edbaac609dfae3938">mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</td></tr>
+<tr class="memdesc:gadadd40aba6dadd0edbaac609dfae3938"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor4.html" title="mem_functor4 wraps methods with 4 argument(s).">sigc::mem_functor4</a> which wraps a method. <a href="group__mem__fun.html#gadadd40aba6dadd0edbaac609dfae3938">More...</a><br /></td></tr>
+<tr class="separator:gadadd40aba6dadd0edbaac609dfae3938"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaa01df6c622d59cfd2d0d8aa3c04c36d1"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gaa01df6c622d59cfd2d0d8aa3c04c36d1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">const_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gaa01df6c622d59cfd2d0d8aa3c04c36d1">mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)</td></tr>
+<tr class="memdesc:gaa01df6c622d59cfd2d0d8aa3c04c36d1"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html" title="const_volatile_mem_functor5 wraps const volatile methods with 5 argument(s).">sigc::const_volatile_mem_functor5</a> which wraps a const volatile method. <a href="namespacesigc.html#gaa01df6c622d59cfd2d0d8aa3c04c36d1">More...</a><br /></td></tr>
+<tr class="separator:gaa01df6c622d59cfd2d0d8aa3c04c36d1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaa01df6c622d59cfd2d0d8aa3c04c36d1"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gaa01df6c622d59cfd2d0d8aa3c04c36d1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor5.html">const_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gaa01df6c622d59cfd2d0d8aa3c04c36d1">mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)</td></tr>
+<tr class="memdesc:gaa01df6c622d59cfd2d0d8aa3c04c36d1"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor5.html" title="const_mem_functor5 wraps const methods with 5 argument(s).">sigc::const_mem_functor5</a> which wraps a const method. <a href="namespacesigc.html#gaa01df6c622d59cfd2d0d8aa3c04c36d1">More...</a><br /></td></tr>
+<tr class="separator:gaa01df6c622d59cfd2d0d8aa3c04c36d1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaa01df6c622d59cfd2d0d8aa3c04c36d1"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gaa01df6c622d59cfd2d0d8aa3c04c36d1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor5.html">volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gaa01df6c622d59cfd2d0d8aa3c04c36d1">mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)</td></tr>
+<tr class="memdesc:gaa01df6c622d59cfd2d0d8aa3c04c36d1"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor5.html" title="volatile_mem_functor5 wraps volatile methods with 5 argument(s).">sigc::volatile_mem_functor5</a> which wraps a volatile method. <a href="namespacesigc.html#gaa01df6c622d59cfd2d0d8aa3c04c36d1">More...</a><br /></td></tr>
+<tr class="separator:gaa01df6c622d59cfd2d0d8aa3c04c36d1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaa01df6c622d59cfd2d0d8aa3c04c36d1"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gaa01df6c622d59cfd2d0d8aa3c04c36d1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor5.html">mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gaa01df6c622d59cfd2d0d8aa3c04c36d1">mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</td></tr>
+<tr class="memdesc:gaa01df6c622d59cfd2d0d8aa3c04c36d1"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor5.html" title="mem_functor5 wraps methods with 5 argument(s).">sigc::mem_functor5</a> which wraps a method. <a href="group__mem__fun.html#gaa01df6c622d59cfd2d0d8aa3c04c36d1">More...</a><br /></td></tr>
+<tr class="separator:gaa01df6c622d59cfd2d0d8aa3c04c36d1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga9030b647c35e06c68342fee34e8fd320"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga9030b647c35e06c68342fee34e8fd320"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">const_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga9030b647c35e06c68342fee34e8fd320">mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)</td></tr>
+<tr class="memdesc:ga9030b647c35e06c68342fee34e8fd320"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html" title="const_volatile_mem_functor6 wraps const volatile methods with 6 argument(s).">sigc::const_volatile_mem_functor6</a> which wraps a const volatile method. <a href="namespacesigc.html#ga9030b647c35e06c68342fee34e8fd320">More...</a><br /></td></tr>
+<tr class="separator:ga9030b647c35e06c68342fee34e8fd320"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga9030b647c35e06c68342fee34e8fd320"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga9030b647c35e06c68342fee34e8fd320"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor6.html">const_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga9030b647c35e06c68342fee34e8fd320">mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)</td></tr>
+<tr class="memdesc:ga9030b647c35e06c68342fee34e8fd320"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor6.html" title="const_mem_functor6 wraps const methods with 6 argument(s).">sigc::const_mem_functor6</a> which wraps a const method. <a href="namespacesigc.html#ga9030b647c35e06c68342fee34e8fd320">More...</a><br /></td></tr>
+<tr class="separator:ga9030b647c35e06c68342fee34e8fd320"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga9030b647c35e06c68342fee34e8fd320"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga9030b647c35e06c68342fee34e8fd320"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor6.html">volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga9030b647c35e06c68342fee34e8fd320">mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)</td></tr>
+<tr class="memdesc:ga9030b647c35e06c68342fee34e8fd320"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor6.html" title="volatile_mem_functor6 wraps volatile methods with 6 argument(s).">sigc::volatile_mem_functor6</a> which wraps a volatile method. <a href="namespacesigc.html#ga9030b647c35e06c68342fee34e8fd320">More...</a><br /></td></tr>
+<tr class="separator:ga9030b647c35e06c68342fee34e8fd320"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga9030b647c35e06c68342fee34e8fd320"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga9030b647c35e06c68342fee34e8fd320"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor6.html">mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga9030b647c35e06c68342fee34e8fd320">mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</td></tr>
+<tr class="memdesc:ga9030b647c35e06c68342fee34e8fd320"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor6.html" title="mem_functor6 wraps methods with 6 argument(s).">sigc::mem_functor6</a> which wraps a method. <a href="group__mem__fun.html#ga9030b647c35e06c68342fee34e8fd320">More...</a><br /></td></tr>
+<tr class="separator:ga9030b647c35e06c68342fee34e8fd320"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga54e4bf947e8c93c56931b8e8f7ed0d2e"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga54e4bf947e8c93c56931b8e8f7ed0d2e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">const_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga54e4bf947e8c93c56931b8e8f7ed0d2e">mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)</td></tr>
+<tr class="memdesc:ga54e4bf947e8c93c56931b8e8f7ed0d2e"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html" title="const_volatile_mem_functor7 wraps const volatile methods with 7 argument(s).">sigc::const_volatile_mem_functor7</a> which wraps a const volatile method. <a href="namespacesigc.html#ga54e4bf947e8c93c56931b8e8f7ed0d2e">More...</a><br /></td></tr>
+<tr class="separator:ga54e4bf947e8c93c56931b8e8f7ed0d2e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga54e4bf947e8c93c56931b8e8f7ed0d2e"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga54e4bf947e8c93c56931b8e8f7ed0d2e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor7.html">const_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga54e4bf947e8c93c56931b8e8f7ed0d2e">mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)</td></tr>
+<tr class="memdesc:ga54e4bf947e8c93c56931b8e8f7ed0d2e"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor7.html" title="const_mem_functor7 wraps const methods with 7 argument(s).">sigc::const_mem_functor7</a> which wraps a const method. <a href="namespacesigc.html#ga54e4bf947e8c93c56931b8e8f7ed0d2e">More...</a><br /></td></tr>
+<tr class="separator:ga54e4bf947e8c93c56931b8e8f7ed0d2e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga54e4bf947e8c93c56931b8e8f7ed0d2e"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga54e4bf947e8c93c56931b8e8f7ed0d2e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor7.html">volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga54e4bf947e8c93c56931b8e8f7ed0d2e">mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)</td></tr>
+<tr class="memdesc:ga54e4bf947e8c93c56931b8e8f7ed0d2e"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor7.html" title="volatile_mem_functor7 wraps volatile methods with 7 argument(s).">sigc::volatile_mem_functor7</a> which wraps a volatile method. <a href="namespacesigc.html#ga54e4bf947e8c93c56931b8e8f7ed0d2e">More...</a><br /></td></tr>
+<tr class="separator:ga54e4bf947e8c93c56931b8e8f7ed0d2e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga54e4bf947e8c93c56931b8e8f7ed0d2e"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga54e4bf947e8c93c56931b8e8f7ed0d2e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor7.html">mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga54e4bf947e8c93c56931b8e8f7ed0d2e">mem_fun</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</td></tr>
+<tr class="memdesc:ga54e4bf947e8c93c56931b8e8f7ed0d2e"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor7.html" title="mem_functor7 wraps methods with 7 argument(s).">sigc::mem_functor7</a> which wraps a method. <a href="group__mem__fun.html#ga54e4bf947e8c93c56931b8e8f7ed0d2e">More...</a><br /></td></tr>
+<tr class="separator:ga54e4bf947e8c93c56931b8e8f7ed0d2e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaf71277763f14050e2d270fcf3ea41dc9"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaf71277763f14050e2d270fcf3ea41dc9"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">bound_const_volatile_mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gaf71277763f14050e2d270fcf3ea41dc9">mem_fun0</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)() const volatile)</td></tr>
+<tr class="memdesc:gaf71277763f14050e2d270fcf3ea41dc9"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html" title="bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object...">sigc::bound_const_volatile_mem_functor0</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gaf71277763f14050e2d270fcf3ea41dc9">More...</a><br /></td></tr>
+<tr class="separator:gaf71277763f14050e2d270fcf3ea41dc9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaf71277763f14050e2d270fcf3ea41dc9"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaf71277763f14050e2d270fcf3ea41dc9"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html">bound_const_mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gaf71277763f14050e2d270fcf3ea41dc9">mem_fun0</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)() const)</td></tr>
+<tr class="memdesc:gaf71277763f14050e2d270fcf3ea41dc9"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor0.html" title="bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance.">sigc::bound_const_mem_functor0</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gaf71277763f14050e2d270fcf3ea41dc9">More...</a><br /></td></tr>
+<tr class="separator:gaf71277763f14050e2d270fcf3ea41dc9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaf71277763f14050e2d270fcf3ea41dc9"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaf71277763f14050e2d270fcf3ea41dc9"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">bound_volatile_mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gaf71277763f14050e2d270fcf3ea41dc9">mem_fun0</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)() volatile)</td></tr>
+<tr class="memdesc:gaf71277763f14050e2d270fcf3ea41dc9"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html" title="bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance.">sigc::bound_volatile_mem_functor0</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gaf71277763f14050e2d270fcf3ea41dc9">More...</a><br /></td></tr>
+<tr class="separator:gaf71277763f14050e2d270fcf3ea41dc9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaf71277763f14050e2d270fcf3ea41dc9"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaf71277763f14050e2d270fcf3ea41dc9"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor0.html">bound_mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gaf71277763f14050e2d270fcf3ea41dc9">mem_fun0</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)())</td></tr>
+<tr class="memdesc:gaf71277763f14050e2d270fcf3ea41dc9"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor0.html" title="bound_mem_functor0 encapsulates a method with 0 arguments and an object instance.">sigc::bound_mem_functor0</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#gaf71277763f14050e2d270fcf3ea41dc9">More...</a><br /></td></tr>
+<tr class="separator:gaf71277763f14050e2d270fcf3ea41dc9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gae03d0b73b85e85d2ad8bc43b19b855e3"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gae03d0b73b85e85d2ad8bc43b19b855e3"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">bound_const_volatile_mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gae03d0b73b85e85d2ad8bc43b19b855e3">mem_fun0</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)() const volatile)</td></tr>
+<tr class="memdesc:gae03d0b73b85e85d2ad8bc43b19b855e3"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html" title="bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object...">sigc::bound_const_volatile_mem_functor0</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gae03d0b73b85e85d2ad8bc43b19b855e3">More...</a><br /></td></tr>
+<tr class="separator:gae03d0b73b85e85d2ad8bc43b19b855e3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gae03d0b73b85e85d2ad8bc43b19b855e3"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gae03d0b73b85e85d2ad8bc43b19b855e3"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html">bound_const_mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gae03d0b73b85e85d2ad8bc43b19b855e3">mem_fun0</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)() const)</td></tr>
+<tr class="memdesc:gae03d0b73b85e85d2ad8bc43b19b855e3"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor0.html" title="bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance.">sigc::bound_const_mem_functor0</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gae03d0b73b85e85d2ad8bc43b19b855e3">More...</a><br /></td></tr>
+<tr class="separator:gae03d0b73b85e85d2ad8bc43b19b855e3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gae03d0b73b85e85d2ad8bc43b19b855e3"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gae03d0b73b85e85d2ad8bc43b19b855e3"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">bound_volatile_mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gae03d0b73b85e85d2ad8bc43b19b855e3">mem_fun0</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)() volatile)</td></tr>
+<tr class="memdesc:gae03d0b73b85e85d2ad8bc43b19b855e3"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html" title="bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance.">sigc::bound_volatile_mem_functor0</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gae03d0b73b85e85d2ad8bc43b19b855e3">More...</a><br /></td></tr>
+<tr class="separator:gae03d0b73b85e85d2ad8bc43b19b855e3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gae03d0b73b85e85d2ad8bc43b19b855e3"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gae03d0b73b85e85d2ad8bc43b19b855e3"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor0.html">bound_mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gae03d0b73b85e85d2ad8bc43b19b855e3">mem_fun0</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)())</td></tr>
+<tr class="memdesc:gae03d0b73b85e85d2ad8bc43b19b855e3"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor0.html" title="bound_mem_functor0 encapsulates a method with 0 arguments and an object instance.">sigc::bound_mem_functor0</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#gae03d0b73b85e85d2ad8bc43b19b855e3">More...</a><br /></td></tr>
+<tr class="separator:gae03d0b73b85e85d2ad8bc43b19b855e3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga765b35689a909fbc2a627be8256c5b1f"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga765b35689a909fbc2a627be8256c5b1f"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">const_volatile_mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga765b35689a909fbc2a627be8256c5b1f">mem_fun0</a> (T_return(T_obj::* _A_func)() const volatile)</td></tr>
+<tr class="memdesc:ga765b35689a909fbc2a627be8256c5b1f"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html" title="const_volatile_mem_functor0 wraps const volatile methods with 0 argument(s).">sigc::const_volatile_mem_functor0</a> which wraps a const volatile method. <a href="namespacesigc.html#ga765b35689a909fbc2a627be8256c5b1f">More...</a><br /></td></tr>
+<tr class="separator:ga765b35689a909fbc2a627be8256c5b1f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga765b35689a909fbc2a627be8256c5b1f"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga765b35689a909fbc2a627be8256c5b1f"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor0.html">const_mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga765b35689a909fbc2a627be8256c5b1f">mem_fun0</a> (T_return(T_obj::* _A_func)() const)</td></tr>
+<tr class="memdesc:ga765b35689a909fbc2a627be8256c5b1f"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor0.html" title="const_mem_functor0 wraps const methods with 0 argument(s).">sigc::const_mem_functor0</a> which wraps a const method. <a href="namespacesigc.html#ga765b35689a909fbc2a627be8256c5b1f">More...</a><br /></td></tr>
+<tr class="separator:ga765b35689a909fbc2a627be8256c5b1f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga765b35689a909fbc2a627be8256c5b1f"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga765b35689a909fbc2a627be8256c5b1f"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor0.html">volatile_mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga765b35689a909fbc2a627be8256c5b1f">mem_fun0</a> (T_return(T_obj::* _A_func)() volatile)</td></tr>
+<tr class="memdesc:ga765b35689a909fbc2a627be8256c5b1f"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor0.html" title="volatile_mem_functor0 wraps volatile methods with 0 argument(s).">sigc::volatile_mem_functor0</a> which wraps a volatile method. <a href="namespacesigc.html#ga765b35689a909fbc2a627be8256c5b1f">More...</a><br /></td></tr>
+<tr class="separator:ga765b35689a909fbc2a627be8256c5b1f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga765b35689a909fbc2a627be8256c5b1f"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga765b35689a909fbc2a627be8256c5b1f"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor0.html">mem_functor0</a>< T_return, T_obj > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga765b35689a909fbc2a627be8256c5b1f">mem_fun0</a> (T_return(T_obj::* _A_func)())</td></tr>
+<tr class="memdesc:ga765b35689a909fbc2a627be8256c5b1f"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor0.html" title="mem_functor0 wraps methods with 0 argument(s).">sigc::mem_functor0</a> which wraps a method. <a href="group__mem__fun.html#ga765b35689a909fbc2a627be8256c5b1f">More...</a><br /></td></tr>
+<tr class="separator:ga765b35689a909fbc2a627be8256c5b1f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaade596a4dacfd1429039525bb9f399d0"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaade596a4dacfd1429039525bb9f399d0"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">bound_const_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gaade596a4dacfd1429039525bb9f399d0">mem_fun1</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1) const volatile)</td></tr>
+<tr class="memdesc:gaade596a4dacfd1429039525bb9f399d0"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html" title="bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object...">sigc::bound_const_volatile_mem_functor1</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gaade596a4dacfd1429039525bb9f399d0">More...</a><br /></td></tr>
+<tr class="separator:gaade596a4dacfd1429039525bb9f399d0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaade596a4dacfd1429039525bb9f399d0"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaade596a4dacfd1429039525bb9f399d0"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html">bound_const_mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gaade596a4dacfd1429039525bb9f399d0">mem_fun1</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1) const)</td></tr>
+<tr class="memdesc:gaade596a4dacfd1429039525bb9f399d0"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor1.html" title="bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance.">sigc::bound_const_mem_functor1</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gaade596a4dacfd1429039525bb9f399d0">More...</a><br /></td></tr>
+<tr class="separator:gaade596a4dacfd1429039525bb9f399d0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaade596a4dacfd1429039525bb9f399d0"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaade596a4dacfd1429039525bb9f399d0"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">bound_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gaade596a4dacfd1429039525bb9f399d0">mem_fun1</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1) volatile)</td></tr>
+<tr class="memdesc:gaade596a4dacfd1429039525bb9f399d0"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html" title="bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance.">sigc::bound_volatile_mem_functor1</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gaade596a4dacfd1429039525bb9f399d0">More...</a><br /></td></tr>
+<tr class="separator:gaade596a4dacfd1429039525bb9f399d0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaade596a4dacfd1429039525bb9f399d0"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaade596a4dacfd1429039525bb9f399d0"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor1.html">bound_mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gaade596a4dacfd1429039525bb9f399d0">mem_fun1</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1))</td></tr>
+<tr class="memdesc:gaade596a4dacfd1429039525bb9f399d0"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor1.html" title="bound_mem_functor1 encapsulates a method with 1 arguments and an object instance.">sigc::bound_mem_functor1</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#gaade596a4dacfd1429039525bb9f399d0">More...</a><br /></td></tr>
+<tr class="separator:gaade596a4dacfd1429039525bb9f399d0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga3dd8d2ed97310dbf4fa394999f0be7b7"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga3dd8d2ed97310dbf4fa394999f0be7b7"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">bound_const_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga3dd8d2ed97310dbf4fa394999f0be7b7">mem_fun1</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1) const volatile)</td></tr>
+<tr class="memdesc:ga3dd8d2ed97310dbf4fa394999f0be7b7"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html" title="bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object...">sigc::bound_const_volatile_mem_functor1</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga3dd8d2ed97310dbf4fa394999f0be7b7">More...</a><br /></td></tr>
+<tr class="separator:ga3dd8d2ed97310dbf4fa394999f0be7b7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga3dd8d2ed97310dbf4fa394999f0be7b7"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga3dd8d2ed97310dbf4fa394999f0be7b7"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html">bound_const_mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga3dd8d2ed97310dbf4fa394999f0be7b7">mem_fun1</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1) const)</td></tr>
+<tr class="memdesc:ga3dd8d2ed97310dbf4fa394999f0be7b7"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor1.html" title="bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance.">sigc::bound_const_mem_functor1</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga3dd8d2ed97310dbf4fa394999f0be7b7">More...</a><br /></td></tr>
+<tr class="separator:ga3dd8d2ed97310dbf4fa394999f0be7b7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga3dd8d2ed97310dbf4fa394999f0be7b7"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga3dd8d2ed97310dbf4fa394999f0be7b7"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">bound_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga3dd8d2ed97310dbf4fa394999f0be7b7">mem_fun1</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1) volatile)</td></tr>
+<tr class="memdesc:ga3dd8d2ed97310dbf4fa394999f0be7b7"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html" title="bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance.">sigc::bound_volatile_mem_functor1</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga3dd8d2ed97310dbf4fa394999f0be7b7">More...</a><br /></td></tr>
+<tr class="separator:ga3dd8d2ed97310dbf4fa394999f0be7b7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga3dd8d2ed97310dbf4fa394999f0be7b7"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga3dd8d2ed97310dbf4fa394999f0be7b7"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor1.html">bound_mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga3dd8d2ed97310dbf4fa394999f0be7b7">mem_fun1</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1))</td></tr>
+<tr class="memdesc:ga3dd8d2ed97310dbf4fa394999f0be7b7"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor1.html" title="bound_mem_functor1 encapsulates a method with 1 arguments and an object instance.">sigc::bound_mem_functor1</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga3dd8d2ed97310dbf4fa394999f0be7b7">More...</a><br /></td></tr>
+<tr class="separator:ga3dd8d2ed97310dbf4fa394999f0be7b7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gae0bebf0d8a2d36d93746c23d9eea668d"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gae0bebf0d8a2d36d93746c23d9eea668d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">const_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gae0bebf0d8a2d36d93746c23d9eea668d">mem_fun1</a> (T_return(T_obj::* _A_func)(T_arg1) const volatile)</td></tr>
+<tr class="memdesc:gae0bebf0d8a2d36d93746c23d9eea668d"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html" title="const_volatile_mem_functor1 wraps const volatile methods with 1 argument(s).">sigc::const_volatile_mem_functor1</a> which wraps a const volatile method. <a href="namespacesigc.html#gae0bebf0d8a2d36d93746c23d9eea668d">More...</a><br /></td></tr>
+<tr class="separator:gae0bebf0d8a2d36d93746c23d9eea668d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gae0bebf0d8a2d36d93746c23d9eea668d"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gae0bebf0d8a2d36d93746c23d9eea668d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor1.html">const_mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gae0bebf0d8a2d36d93746c23d9eea668d">mem_fun1</a> (T_return(T_obj::* _A_func)(T_arg1) const)</td></tr>
+<tr class="memdesc:gae0bebf0d8a2d36d93746c23d9eea668d"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor1.html" title="const_mem_functor1 wraps const methods with 1 argument(s).">sigc::const_mem_functor1</a> which wraps a const method. <a href="namespacesigc.html#gae0bebf0d8a2d36d93746c23d9eea668d">More...</a><br /></td></tr>
+<tr class="separator:gae0bebf0d8a2d36d93746c23d9eea668d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gae0bebf0d8a2d36d93746c23d9eea668d"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gae0bebf0d8a2d36d93746c23d9eea668d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor1.html">volatile_mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gae0bebf0d8a2d36d93746c23d9eea668d">mem_fun1</a> (T_return(T_obj::* _A_func)(T_arg1) volatile)</td></tr>
+<tr class="memdesc:gae0bebf0d8a2d36d93746c23d9eea668d"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor1.html" title="volatile_mem_functor1 wraps volatile methods with 1 argument(s).">sigc::volatile_mem_functor1</a> which wraps a volatile method. <a href="namespacesigc.html#gae0bebf0d8a2d36d93746c23d9eea668d">More...</a><br /></td></tr>
+<tr class="separator:gae0bebf0d8a2d36d93746c23d9eea668d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gae0bebf0d8a2d36d93746c23d9eea668d"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gae0bebf0d8a2d36d93746c23d9eea668d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor1.html">mem_functor1</a>< T_return, T_obj, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gae0bebf0d8a2d36d93746c23d9eea668d">mem_fun1</a> (T_return(T_obj::* _A_func)(T_arg1))</td></tr>
+<tr class="memdesc:gae0bebf0d8a2d36d93746c23d9eea668d"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor1.html" title="mem_functor1 wraps methods with 1 argument(s).">sigc::mem_functor1</a> which wraps a method. <a href="group__mem__fun.html#gae0bebf0d8a2d36d93746c23d9eea668d">More...</a><br /></td></tr>
+<tr class="separator:gae0bebf0d8a2d36d93746c23d9eea668d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaee7652f1a0625df50af50e28b5e2423e"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaee7652f1a0625df50af50e28b5e2423e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">bound_const_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gaee7652f1a0625df50af50e28b5e2423e">mem_fun2</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) const volatile)</td></tr>
+<tr class="memdesc:gaee7652f1a0625df50af50e28b5e2423e"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html" title="bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object...">sigc::bound_const_volatile_mem_functor2</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gaee7652f1a0625df50af50e28b5e2423e">More...</a><br /></td></tr>
+<tr class="separator:gaee7652f1a0625df50af50e28b5e2423e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaee7652f1a0625df50af50e28b5e2423e"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaee7652f1a0625df50af50e28b5e2423e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html">bound_const_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gaee7652f1a0625df50af50e28b5e2423e">mem_fun2</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) const)</td></tr>
+<tr class="memdesc:gaee7652f1a0625df50af50e28b5e2423e"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor2.html" title="bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance.">sigc::bound_const_mem_functor2</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gaee7652f1a0625df50af50e28b5e2423e">More...</a><br /></td></tr>
+<tr class="separator:gaee7652f1a0625df50af50e28b5e2423e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaee7652f1a0625df50af50e28b5e2423e"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaee7652f1a0625df50af50e28b5e2423e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">bound_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gaee7652f1a0625df50af50e28b5e2423e">mem_fun2</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) volatile)</td></tr>
+<tr class="memdesc:gaee7652f1a0625df50af50e28b5e2423e"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html" title="bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance.">sigc::bound_volatile_mem_functor2</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gaee7652f1a0625df50af50e28b5e2423e">More...</a><br /></td></tr>
+<tr class="separator:gaee7652f1a0625df50af50e28b5e2423e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaee7652f1a0625df50af50e28b5e2423e"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaee7652f1a0625df50af50e28b5e2423e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor2.html">bound_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gaee7652f1a0625df50af50e28b5e2423e">mem_fun2</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2))</td></tr>
+<tr class="memdesc:gaee7652f1a0625df50af50e28b5e2423e"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor2.html" title="bound_mem_functor2 encapsulates a method with 2 arguments and an object instance.">sigc::bound_mem_functor2</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#gaee7652f1a0625df50af50e28b5e2423e">More...</a><br /></td></tr>
+<tr class="separator:gaee7652f1a0625df50af50e28b5e2423e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga184da4166c8b5409dc4b98d7bc16dff8"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga184da4166c8b5409dc4b98d7bc16dff8"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">bound_const_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga184da4166c8b5409dc4b98d7bc16dff8">mem_fun2</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) const volatile)</td></tr>
+<tr class="memdesc:ga184da4166c8b5409dc4b98d7bc16dff8"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html" title="bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object...">sigc::bound_const_volatile_mem_functor2</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga184da4166c8b5409dc4b98d7bc16dff8">More...</a><br /></td></tr>
+<tr class="separator:ga184da4166c8b5409dc4b98d7bc16dff8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga184da4166c8b5409dc4b98d7bc16dff8"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga184da4166c8b5409dc4b98d7bc16dff8"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html">bound_const_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga184da4166c8b5409dc4b98d7bc16dff8">mem_fun2</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) const)</td></tr>
+<tr class="memdesc:ga184da4166c8b5409dc4b98d7bc16dff8"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor2.html" title="bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance.">sigc::bound_const_mem_functor2</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga184da4166c8b5409dc4b98d7bc16dff8">More...</a><br /></td></tr>
+<tr class="separator:ga184da4166c8b5409dc4b98d7bc16dff8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga184da4166c8b5409dc4b98d7bc16dff8"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga184da4166c8b5409dc4b98d7bc16dff8"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">bound_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga184da4166c8b5409dc4b98d7bc16dff8">mem_fun2</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) volatile)</td></tr>
+<tr class="memdesc:ga184da4166c8b5409dc4b98d7bc16dff8"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html" title="bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance.">sigc::bound_volatile_mem_functor2</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga184da4166c8b5409dc4b98d7bc16dff8">More...</a><br /></td></tr>
+<tr class="separator:ga184da4166c8b5409dc4b98d7bc16dff8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga184da4166c8b5409dc4b98d7bc16dff8"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga184da4166c8b5409dc4b98d7bc16dff8"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor2.html">bound_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga184da4166c8b5409dc4b98d7bc16dff8">mem_fun2</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2))</td></tr>
+<tr class="memdesc:ga184da4166c8b5409dc4b98d7bc16dff8"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor2.html" title="bound_mem_functor2 encapsulates a method with 2 arguments and an object instance.">sigc::bound_mem_functor2</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga184da4166c8b5409dc4b98d7bc16dff8">More...</a><br /></td></tr>
+<tr class="separator:ga184da4166c8b5409dc4b98d7bc16dff8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gab76f41aeada332b353b6fe2e96008831"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gab76f41aeada332b353b6fe2e96008831"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">const_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gab76f41aeada332b353b6fe2e96008831">mem_fun2</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2) const volatile)</td></tr>
+<tr class="memdesc:gab76f41aeada332b353b6fe2e96008831"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html" title="const_volatile_mem_functor2 wraps const volatile methods with 2 argument(s).">sigc::const_volatile_mem_functor2</a> which wraps a const volatile method. <a href="namespacesigc.html#gab76f41aeada332b353b6fe2e96008831">More...</a><br /></td></tr>
+<tr class="separator:gab76f41aeada332b353b6fe2e96008831"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gab76f41aeada332b353b6fe2e96008831"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gab76f41aeada332b353b6fe2e96008831"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor2.html">const_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gab76f41aeada332b353b6fe2e96008831">mem_fun2</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2) const)</td></tr>
+<tr class="memdesc:gab76f41aeada332b353b6fe2e96008831"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor2.html" title="const_mem_functor2 wraps const methods with 2 argument(s).">sigc::const_mem_functor2</a> which wraps a const method. <a href="namespacesigc.html#gab76f41aeada332b353b6fe2e96008831">More...</a><br /></td></tr>
+<tr class="separator:gab76f41aeada332b353b6fe2e96008831"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gab76f41aeada332b353b6fe2e96008831"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gab76f41aeada332b353b6fe2e96008831"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor2.html">volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gab76f41aeada332b353b6fe2e96008831">mem_fun2</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2) volatile)</td></tr>
+<tr class="memdesc:gab76f41aeada332b353b6fe2e96008831"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor2.html" title="volatile_mem_functor2 wraps volatile methods with 2 argument(s).">sigc::volatile_mem_functor2</a> which wraps a volatile method. <a href="namespacesigc.html#gab76f41aeada332b353b6fe2e96008831">More...</a><br /></td></tr>
+<tr class="separator:gab76f41aeada332b353b6fe2e96008831"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gab76f41aeada332b353b6fe2e96008831"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:gab76f41aeada332b353b6fe2e96008831"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor2.html">mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gab76f41aeada332b353b6fe2e96008831">mem_fun2</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2))</td></tr>
+<tr class="memdesc:gab76f41aeada332b353b6fe2e96008831"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor2.html" title="mem_functor2 wraps methods with 2 argument(s).">sigc::mem_functor2</a> which wraps a method. <a href="group__mem__fun.html#gab76f41aeada332b353b6fe2e96008831">More...</a><br /></td></tr>
+<tr class="separator:gab76f41aeada332b353b6fe2e96008831"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga14e07df139b5cb6897e671c50fc33cde"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga14e07df139b5cb6897e671c50fc33cde"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">bound_const_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga14e07df139b5cb6897e671c50fc33cde">mem_fun3</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) const volatile)</td></tr>
+<tr class="memdesc:ga14e07df139b5cb6897e671c50fc33cde"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html" title="bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object...">sigc::bound_const_volatile_mem_functor3</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga14e07df139b5cb6897e671c50fc33cde">More...</a><br /></td></tr>
+<tr class="separator:ga14e07df139b5cb6897e671c50fc33cde"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga14e07df139b5cb6897e671c50fc33cde"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga14e07df139b5cb6897e671c50fc33cde"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html">bound_const_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga14e07df139b5cb6897e671c50fc33cde">mem_fun3</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) const)</td></tr>
+<tr class="memdesc:ga14e07df139b5cb6897e671c50fc33cde"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor3.html" title="bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance.">sigc::bound_const_mem_functor3</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga14e07df139b5cb6897e671c50fc33cde">More...</a><br /></td></tr>
+<tr class="separator:ga14e07df139b5cb6897e671c50fc33cde"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga14e07df139b5cb6897e671c50fc33cde"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga14e07df139b5cb6897e671c50fc33cde"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">bound_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga14e07df139b5cb6897e671c50fc33cde">mem_fun3</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) volatile)</td></tr>
+<tr class="memdesc:ga14e07df139b5cb6897e671c50fc33cde"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html" title="bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance.">sigc::bound_volatile_mem_functor3</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga14e07df139b5cb6897e671c50fc33cde">More...</a><br /></td></tr>
+<tr class="separator:ga14e07df139b5cb6897e671c50fc33cde"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga14e07df139b5cb6897e671c50fc33cde"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga14e07df139b5cb6897e671c50fc33cde"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor3.html">bound_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga14e07df139b5cb6897e671c50fc33cde">mem_fun3</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3))</td></tr>
+<tr class="memdesc:ga14e07df139b5cb6897e671c50fc33cde"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor3.html" title="bound_mem_functor3 encapsulates a method with 3 arguments and an object instance.">sigc::bound_mem_functor3</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga14e07df139b5cb6897e671c50fc33cde">More...</a><br /></td></tr>
+<tr class="separator:ga14e07df139b5cb6897e671c50fc33cde"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga4f2fdbf02e8cac9492326a4a8ffdd012"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga4f2fdbf02e8cac9492326a4a8ffdd012"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">bound_const_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga4f2fdbf02e8cac9492326a4a8ffdd012">mem_fun3</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) const volatile)</td></tr>
+<tr class="memdesc:ga4f2fdbf02e8cac9492326a4a8ffdd012"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html" title="bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object...">sigc::bound_const_volatile_mem_functor3</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga4f2fdbf02e8cac9492326a4a8ffdd012">More...</a><br /></td></tr>
+<tr class="separator:ga4f2fdbf02e8cac9492326a4a8ffdd012"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga4f2fdbf02e8cac9492326a4a8ffdd012"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga4f2fdbf02e8cac9492326a4a8ffdd012"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html">bound_const_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga4f2fdbf02e8cac9492326a4a8ffdd012">mem_fun3</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) const)</td></tr>
+<tr class="memdesc:ga4f2fdbf02e8cac9492326a4a8ffdd012"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor3.html" title="bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance.">sigc::bound_const_mem_functor3</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga4f2fdbf02e8cac9492326a4a8ffdd012">More...</a><br /></td></tr>
+<tr class="separator:ga4f2fdbf02e8cac9492326a4a8ffdd012"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga4f2fdbf02e8cac9492326a4a8ffdd012"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga4f2fdbf02e8cac9492326a4a8ffdd012"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">bound_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga4f2fdbf02e8cac9492326a4a8ffdd012">mem_fun3</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) volatile)</td></tr>
+<tr class="memdesc:ga4f2fdbf02e8cac9492326a4a8ffdd012"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html" title="bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance.">sigc::bound_volatile_mem_functor3</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga4f2fdbf02e8cac9492326a4a8ffdd012">More...</a><br /></td></tr>
+<tr class="separator:ga4f2fdbf02e8cac9492326a4a8ffdd012"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga4f2fdbf02e8cac9492326a4a8ffdd012"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga4f2fdbf02e8cac9492326a4a8ffdd012"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor3.html">bound_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga4f2fdbf02e8cac9492326a4a8ffdd012">mem_fun3</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3))</td></tr>
+<tr class="memdesc:ga4f2fdbf02e8cac9492326a4a8ffdd012"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor3.html" title="bound_mem_functor3 encapsulates a method with 3 arguments and an object instance.">sigc::bound_mem_functor3</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga4f2fdbf02e8cac9492326a4a8ffdd012">More...</a><br /></td></tr>
+<tr class="separator:ga4f2fdbf02e8cac9492326a4a8ffdd012"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga2379e0d689fe4a99c7c669fc29817457"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga2379e0d689fe4a99c7c669fc29817457"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">const_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga2379e0d689fe4a99c7c669fc29817457">mem_fun3</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3) const volatile)</td></tr>
+<tr class="memdesc:ga2379e0d689fe4a99c7c669fc29817457"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html" title="const_volatile_mem_functor3 wraps const volatile methods with 3 argument(s).">sigc::const_volatile_mem_functor3</a> which wraps a const volatile method. <a href="namespacesigc.html#ga2379e0d689fe4a99c7c669fc29817457">More...</a><br /></td></tr>
+<tr class="separator:ga2379e0d689fe4a99c7c669fc29817457"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga2379e0d689fe4a99c7c669fc29817457"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga2379e0d689fe4a99c7c669fc29817457"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor3.html">const_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga2379e0d689fe4a99c7c669fc29817457">mem_fun3</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3) const)</td></tr>
+<tr class="memdesc:ga2379e0d689fe4a99c7c669fc29817457"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor3.html" title="const_mem_functor3 wraps const methods with 3 argument(s).">sigc::const_mem_functor3</a> which wraps a const method. <a href="namespacesigc.html#ga2379e0d689fe4a99c7c669fc29817457">More...</a><br /></td></tr>
+<tr class="separator:ga2379e0d689fe4a99c7c669fc29817457"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga2379e0d689fe4a99c7c669fc29817457"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga2379e0d689fe4a99c7c669fc29817457"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor3.html">volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga2379e0d689fe4a99c7c669fc29817457">mem_fun3</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3) volatile)</td></tr>
+<tr class="memdesc:ga2379e0d689fe4a99c7c669fc29817457"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor3.html" title="volatile_mem_functor3 wraps volatile methods with 3 argument(s).">sigc::volatile_mem_functor3</a> which wraps a volatile method. <a href="namespacesigc.html#ga2379e0d689fe4a99c7c669fc29817457">More...</a><br /></td></tr>
+<tr class="separator:ga2379e0d689fe4a99c7c669fc29817457"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga2379e0d689fe4a99c7c669fc29817457"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga2379e0d689fe4a99c7c669fc29817457"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor3.html">mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga2379e0d689fe4a99c7c669fc29817457">mem_fun3</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3))</td></tr>
+<tr class="memdesc:ga2379e0d689fe4a99c7c669fc29817457"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor3.html" title="mem_functor3 wraps methods with 3 argument(s).">sigc::mem_functor3</a> which wraps a method. <a href="group__mem__fun.html#ga2379e0d689fe4a99c7c669fc29817457">More...</a><br /></td></tr>
+<tr class="separator:ga2379e0d689fe4a99c7c669fc29817457"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga86da5637e2735480d525ffa930e7e21a"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga86da5637e2735480d525ffa930e7e21a"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">bound_const_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga86da5637e2735480d525ffa930e7e21a">mem_fun4</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)</td></tr>
+<tr class="memdesc:ga86da5637e2735480d525ffa930e7e21a"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html" title="bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object...">sigc::bound_const_volatile_mem_functor4</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga86da5637e2735480d525ffa930e7e21a">More...</a><br /></td></tr>
+<tr class="separator:ga86da5637e2735480d525ffa930e7e21a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga86da5637e2735480d525ffa930e7e21a"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga86da5637e2735480d525ffa930e7e21a"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html">bound_const_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga86da5637e2735480d525ffa930e7e21a">mem_fun4</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)</td></tr>
+<tr class="memdesc:ga86da5637e2735480d525ffa930e7e21a"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor4.html" title="bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance.">sigc::bound_const_mem_functor4</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga86da5637e2735480d525ffa930e7e21a">More...</a><br /></td></tr>
+<tr class="separator:ga86da5637e2735480d525ffa930e7e21a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga86da5637e2735480d525ffa930e7e21a"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga86da5637e2735480d525ffa930e7e21a"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">bound_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga86da5637e2735480d525ffa930e7e21a">mem_fun4</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)</td></tr>
+<tr class="memdesc:ga86da5637e2735480d525ffa930e7e21a"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html" title="bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance.">sigc::bound_volatile_mem_functor4</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga86da5637e2735480d525ffa930e7e21a">More...</a><br /></td></tr>
+<tr class="separator:ga86da5637e2735480d525ffa930e7e21a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga86da5637e2735480d525ffa930e7e21a"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga86da5637e2735480d525ffa930e7e21a"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor4.html">bound_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga86da5637e2735480d525ffa930e7e21a">mem_fun4</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</td></tr>
+<tr class="memdesc:ga86da5637e2735480d525ffa930e7e21a"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor4.html" title="bound_mem_functor4 encapsulates a method with 4 arguments and an object instance.">sigc::bound_mem_functor4</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga86da5637e2735480d525ffa930e7e21a">More...</a><br /></td></tr>
+<tr class="separator:ga86da5637e2735480d525ffa930e7e21a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga94a2525ef116e16598b81b853544a170"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga94a2525ef116e16598b81b853544a170"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">bound_const_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga94a2525ef116e16598b81b853544a170">mem_fun4</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)</td></tr>
+<tr class="memdesc:ga94a2525ef116e16598b81b853544a170"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html" title="bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object...">sigc::bound_const_volatile_mem_functor4</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga94a2525ef116e16598b81b853544a170">More...</a><br /></td></tr>
+<tr class="separator:ga94a2525ef116e16598b81b853544a170"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga94a2525ef116e16598b81b853544a170"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga94a2525ef116e16598b81b853544a170"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html">bound_const_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga94a2525ef116e16598b81b853544a170">mem_fun4</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)</td></tr>
+<tr class="memdesc:ga94a2525ef116e16598b81b853544a170"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor4.html" title="bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance.">sigc::bound_const_mem_functor4</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga94a2525ef116e16598b81b853544a170">More...</a><br /></td></tr>
+<tr class="separator:ga94a2525ef116e16598b81b853544a170"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga94a2525ef116e16598b81b853544a170"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga94a2525ef116e16598b81b853544a170"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">bound_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga94a2525ef116e16598b81b853544a170">mem_fun4</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)</td></tr>
+<tr class="memdesc:ga94a2525ef116e16598b81b853544a170"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html" title="bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance.">sigc::bound_volatile_mem_functor4</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga94a2525ef116e16598b81b853544a170">More...</a><br /></td></tr>
+<tr class="separator:ga94a2525ef116e16598b81b853544a170"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga94a2525ef116e16598b81b853544a170"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga94a2525ef116e16598b81b853544a170"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor4.html">bound_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga94a2525ef116e16598b81b853544a170">mem_fun4</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</td></tr>
+<tr class="memdesc:ga94a2525ef116e16598b81b853544a170"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor4.html" title="bound_mem_functor4 encapsulates a method with 4 arguments and an object instance.">sigc::bound_mem_functor4</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga94a2525ef116e16598b81b853544a170">More...</a><br /></td></tr>
+<tr class="separator:ga94a2525ef116e16598b81b853544a170"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga1bedd04f76ad3e21f614912562e95d83"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga1bedd04f76ad3e21f614912562e95d83"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">const_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga1bedd04f76ad3e21f614912562e95d83">mem_fun4</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)</td></tr>
+<tr class="memdesc:ga1bedd04f76ad3e21f614912562e95d83"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html" title="const_volatile_mem_functor4 wraps const volatile methods with 4 argument(s).">sigc::const_volatile_mem_functor4</a> which wraps a const volatile method. <a href="namespacesigc.html#ga1bedd04f76ad3e21f614912562e95d83">More...</a><br /></td></tr>
+<tr class="separator:ga1bedd04f76ad3e21f614912562e95d83"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga1bedd04f76ad3e21f614912562e95d83"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga1bedd04f76ad3e21f614912562e95d83"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor4.html">const_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga1bedd04f76ad3e21f614912562e95d83">mem_fun4</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)</td></tr>
+<tr class="memdesc:ga1bedd04f76ad3e21f614912562e95d83"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor4.html" title="const_mem_functor4 wraps const methods with 4 argument(s).">sigc::const_mem_functor4</a> which wraps a const method. <a href="namespacesigc.html#ga1bedd04f76ad3e21f614912562e95d83">More...</a><br /></td></tr>
+<tr class="separator:ga1bedd04f76ad3e21f614912562e95d83"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga1bedd04f76ad3e21f614912562e95d83"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga1bedd04f76ad3e21f614912562e95d83"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor4.html">volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga1bedd04f76ad3e21f614912562e95d83">mem_fun4</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)</td></tr>
+<tr class="memdesc:ga1bedd04f76ad3e21f614912562e95d83"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor4.html" title="volatile_mem_functor4 wraps volatile methods with 4 argument(s).">sigc::volatile_mem_functor4</a> which wraps a volatile method. <a href="namespacesigc.html#ga1bedd04f76ad3e21f614912562e95d83">More...</a><br /></td></tr>
+<tr class="separator:ga1bedd04f76ad3e21f614912562e95d83"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga1bedd04f76ad3e21f614912562e95d83"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga1bedd04f76ad3e21f614912562e95d83"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor4.html">mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga1bedd04f76ad3e21f614912562e95d83">mem_fun4</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</td></tr>
+<tr class="memdesc:ga1bedd04f76ad3e21f614912562e95d83"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor4.html" title="mem_functor4 wraps methods with 4 argument(s).">sigc::mem_functor4</a> which wraps a method. <a href="group__mem__fun.html#ga1bedd04f76ad3e21f614912562e95d83">More...</a><br /></td></tr>
+<tr class="separator:ga1bedd04f76ad3e21f614912562e95d83"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga5c2ca9cef8c857935a59133a73ef61f2"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga5c2ca9cef8c857935a59133a73ef61f2"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">bound_const_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga5c2ca9cef8c857935a59133a73ef61f2">mem_fun5</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)</td></tr>
+<tr class="memdesc:ga5c2ca9cef8c857935a59133a73ef61f2"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html" title="bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object...">sigc::bound_const_volatile_mem_functor5</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga5c2ca9cef8c857935a59133a73ef61f2">More...</a><br /></td></tr>
+<tr class="separator:ga5c2ca9cef8c857935a59133a73ef61f2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga5c2ca9cef8c857935a59133a73ef61f2"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga5c2ca9cef8c857935a59133a73ef61f2"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html">bound_const_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga5c2ca9cef8c857935a59133a73ef61f2">mem_fun5</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)</td></tr>
+<tr class="memdesc:ga5c2ca9cef8c857935a59133a73ef61f2"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor5.html" title="bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance.">sigc::bound_const_mem_functor5</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga5c2ca9cef8c857935a59133a73ef61f2">More...</a><br /></td></tr>
+<tr class="separator:ga5c2ca9cef8c857935a59133a73ef61f2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga5c2ca9cef8c857935a59133a73ef61f2"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga5c2ca9cef8c857935a59133a73ef61f2"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">bound_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga5c2ca9cef8c857935a59133a73ef61f2">mem_fun5</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)</td></tr>
+<tr class="memdesc:ga5c2ca9cef8c857935a59133a73ef61f2"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html" title="bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance.">sigc::bound_volatile_mem_functor5</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga5c2ca9cef8c857935a59133a73ef61f2">More...</a><br /></td></tr>
+<tr class="separator:ga5c2ca9cef8c857935a59133a73ef61f2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga5c2ca9cef8c857935a59133a73ef61f2"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga5c2ca9cef8c857935a59133a73ef61f2"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor5.html">bound_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga5c2ca9cef8c857935a59133a73ef61f2">mem_fun5</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</td></tr>
+<tr class="memdesc:ga5c2ca9cef8c857935a59133a73ef61f2"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor5.html" title="bound_mem_functor5 encapsulates a method with 5 arguments and an object instance.">sigc::bound_mem_functor5</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga5c2ca9cef8c857935a59133a73ef61f2">More...</a><br /></td></tr>
+<tr class="separator:ga5c2ca9cef8c857935a59133a73ef61f2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaf060fe3a2be4ff7c0f50aef54b4dc8bf"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaf060fe3a2be4ff7c0f50aef54b4dc8bf"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">bound_const_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gaf060fe3a2be4ff7c0f50aef54b4dc8bf">mem_fun5</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)</td></tr>
+<tr class="memdesc:gaf060fe3a2be4ff7c0f50aef54b4dc8bf"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html" title="bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object...">sigc::bound_const_volatile_mem_functor5</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gaf060fe3a2be4ff7c0f50aef54b4dc8bf">More...</a><br /></td></tr>
+<tr class="separator:gaf060fe3a2be4ff7c0f50aef54b4dc8bf"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaf060fe3a2be4ff7c0f50aef54b4dc8bf"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaf060fe3a2be4ff7c0f50aef54b4dc8bf"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html">bound_const_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gaf060fe3a2be4ff7c0f50aef54b4dc8bf">mem_fun5</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)</td></tr>
+<tr class="memdesc:gaf060fe3a2be4ff7c0f50aef54b4dc8bf"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor5.html" title="bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance.">sigc::bound_const_mem_functor5</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gaf060fe3a2be4ff7c0f50aef54b4dc8bf">More...</a><br /></td></tr>
+<tr class="separator:gaf060fe3a2be4ff7c0f50aef54b4dc8bf"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaf060fe3a2be4ff7c0f50aef54b4dc8bf"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaf060fe3a2be4ff7c0f50aef54b4dc8bf"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">bound_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gaf060fe3a2be4ff7c0f50aef54b4dc8bf">mem_fun5</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)</td></tr>
+<tr class="memdesc:gaf060fe3a2be4ff7c0f50aef54b4dc8bf"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html" title="bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance.">sigc::bound_volatile_mem_functor5</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gaf060fe3a2be4ff7c0f50aef54b4dc8bf">More...</a><br /></td></tr>
+<tr class="separator:gaf060fe3a2be4ff7c0f50aef54b4dc8bf"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaf060fe3a2be4ff7c0f50aef54b4dc8bf"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gaf060fe3a2be4ff7c0f50aef54b4dc8bf"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor5.html">bound_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gaf060fe3a2be4ff7c0f50aef54b4dc8bf">mem_fun5</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</td></tr>
+<tr class="memdesc:gaf060fe3a2be4ff7c0f50aef54b4dc8bf"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor5.html" title="bound_mem_functor5 encapsulates a method with 5 arguments and an object instance.">sigc::bound_mem_functor5</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#gaf060fe3a2be4ff7c0f50aef54b4dc8bf">More...</a><br /></td></tr>
+<tr class="separator:gaf060fe3a2be4ff7c0f50aef54b4dc8bf"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga3ef4bb904a751d29e2b6803ef81f72fa"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga3ef4bb904a751d29e2b6803ef81f72fa"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">const_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga3ef4bb904a751d29e2b6803ef81f72fa">mem_fun5</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)</td></tr>
+<tr class="memdesc:ga3ef4bb904a751d29e2b6803ef81f72fa"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html" title="const_volatile_mem_functor5 wraps const volatile methods with 5 argument(s).">sigc::const_volatile_mem_functor5</a> which wraps a const volatile method. <a href="namespacesigc.html#ga3ef4bb904a751d29e2b6803ef81f72fa">More...</a><br /></td></tr>
+<tr class="separator:ga3ef4bb904a751d29e2b6803ef81f72fa"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga3ef4bb904a751d29e2b6803ef81f72fa"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga3ef4bb904a751d29e2b6803ef81f72fa"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor5.html">const_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga3ef4bb904a751d29e2b6803ef81f72fa">mem_fun5</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)</td></tr>
+<tr class="memdesc:ga3ef4bb904a751d29e2b6803ef81f72fa"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor5.html" title="const_mem_functor5 wraps const methods with 5 argument(s).">sigc::const_mem_functor5</a> which wraps a const method. <a href="namespacesigc.html#ga3ef4bb904a751d29e2b6803ef81f72fa">More...</a><br /></td></tr>
+<tr class="separator:ga3ef4bb904a751d29e2b6803ef81f72fa"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga3ef4bb904a751d29e2b6803ef81f72fa"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga3ef4bb904a751d29e2b6803ef81f72fa"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor5.html">volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga3ef4bb904a751d29e2b6803ef81f72fa">mem_fun5</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)</td></tr>
+<tr class="memdesc:ga3ef4bb904a751d29e2b6803ef81f72fa"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor5.html" title="volatile_mem_functor5 wraps volatile methods with 5 argument(s).">sigc::volatile_mem_functor5</a> which wraps a volatile method. <a href="namespacesigc.html#ga3ef4bb904a751d29e2b6803ef81f72fa">More...</a><br /></td></tr>
+<tr class="separator:ga3ef4bb904a751d29e2b6803ef81f72fa"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga3ef4bb904a751d29e2b6803ef81f72fa"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga3ef4bb904a751d29e2b6803ef81f72fa"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor5.html">mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga3ef4bb904a751d29e2b6803ef81f72fa">mem_fun5</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</td></tr>
+<tr class="memdesc:ga3ef4bb904a751d29e2b6803ef81f72fa"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor5.html" title="mem_functor5 wraps methods with 5 argument(s).">sigc::mem_functor5</a> which wraps a method. <a href="group__mem__fun.html#ga3ef4bb904a751d29e2b6803ef81f72fa">More...</a><br /></td></tr>
+<tr class="separator:ga3ef4bb904a751d29e2b6803ef81f72fa"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga947f4410e62a2996023177e490c882b7"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga947f4410e62a2996023177e490c882b7"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">bound_const_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga947f4410e62a2996023177e490c882b7">mem_fun6</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)</td></tr>
+<tr class="memdesc:ga947f4410e62a2996023177e490c882b7"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html" title="bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object...">sigc::bound_const_volatile_mem_functor6</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga947f4410e62a2996023177e490c882b7">More...</a><br /></td></tr>
+<tr class="separator:ga947f4410e62a2996023177e490c882b7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga947f4410e62a2996023177e490c882b7"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga947f4410e62a2996023177e490c882b7"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html">bound_const_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga947f4410e62a2996023177e490c882b7">mem_fun6</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)</td></tr>
+<tr class="memdesc:ga947f4410e62a2996023177e490c882b7"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor6.html" title="bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance.">sigc::bound_const_mem_functor6</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga947f4410e62a2996023177e490c882b7">More...</a><br /></td></tr>
+<tr class="separator:ga947f4410e62a2996023177e490c882b7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga947f4410e62a2996023177e490c882b7"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga947f4410e62a2996023177e490c882b7"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">bound_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga947f4410e62a2996023177e490c882b7">mem_fun6</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)</td></tr>
+<tr class="memdesc:ga947f4410e62a2996023177e490c882b7"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html" title="bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance.">sigc::bound_volatile_mem_functor6</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga947f4410e62a2996023177e490c882b7">More...</a><br /></td></tr>
+<tr class="separator:ga947f4410e62a2996023177e490c882b7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga947f4410e62a2996023177e490c882b7"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga947f4410e62a2996023177e490c882b7"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor6.html">bound_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga947f4410e62a2996023177e490c882b7">mem_fun6</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</td></tr>
+<tr class="memdesc:ga947f4410e62a2996023177e490c882b7"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor6.html" title="bound_mem_functor6 encapsulates a method with 6 arguments and an object instance.">sigc::bound_mem_functor6</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga947f4410e62a2996023177e490c882b7">More...</a><br /></td></tr>
+<tr class="separator:ga947f4410e62a2996023177e490c882b7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gac0a6242da9bf96642f25c1363dfef383"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gac0a6242da9bf96642f25c1363dfef383"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">bound_const_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gac0a6242da9bf96642f25c1363dfef383">mem_fun6</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)</td></tr>
+<tr class="memdesc:gac0a6242da9bf96642f25c1363dfef383"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html" title="bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object...">sigc::bound_const_volatile_mem_functor6</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gac0a6242da9bf96642f25c1363dfef383">More...</a><br /></td></tr>
+<tr class="separator:gac0a6242da9bf96642f25c1363dfef383"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gac0a6242da9bf96642f25c1363dfef383"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gac0a6242da9bf96642f25c1363dfef383"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html">bound_const_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gac0a6242da9bf96642f25c1363dfef383">mem_fun6</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)</td></tr>
+<tr class="memdesc:gac0a6242da9bf96642f25c1363dfef383"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor6.html" title="bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance.">sigc::bound_const_mem_functor6</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gac0a6242da9bf96642f25c1363dfef383">More...</a><br /></td></tr>
+<tr class="separator:gac0a6242da9bf96642f25c1363dfef383"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gac0a6242da9bf96642f25c1363dfef383"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gac0a6242da9bf96642f25c1363dfef383"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">bound_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#gac0a6242da9bf96642f25c1363dfef383">mem_fun6</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)</td></tr>
+<tr class="memdesc:gac0a6242da9bf96642f25c1363dfef383"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html" title="bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance.">sigc::bound_volatile_mem_functor6</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#gac0a6242da9bf96642f25c1363dfef383">More...</a><br /></td></tr>
+<tr class="separator:gac0a6242da9bf96642f25c1363dfef383"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gac0a6242da9bf96642f25c1363dfef383"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:gac0a6242da9bf96642f25c1363dfef383"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor6.html">bound_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#gac0a6242da9bf96642f25c1363dfef383">mem_fun6</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</td></tr>
+<tr class="memdesc:gac0a6242da9bf96642f25c1363dfef383"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor6.html" title="bound_mem_functor6 encapsulates a method with 6 arguments and an object instance.">sigc::bound_mem_functor6</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#gac0a6242da9bf96642f25c1363dfef383">More...</a><br /></td></tr>
+<tr class="separator:gac0a6242da9bf96642f25c1363dfef383"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga34ace98fbbd18cb635795639d0f22678"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga34ace98fbbd18cb635795639d0f22678"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">const_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga34ace98fbbd18cb635795639d0f22678">mem_fun6</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)</td></tr>
+<tr class="memdesc:ga34ace98fbbd18cb635795639d0f22678"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html" title="const_volatile_mem_functor6 wraps const volatile methods with 6 argument(s).">sigc::const_volatile_mem_functor6</a> which wraps a const volatile method. <a href="namespacesigc.html#ga34ace98fbbd18cb635795639d0f22678">More...</a><br /></td></tr>
+<tr class="separator:ga34ace98fbbd18cb635795639d0f22678"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga34ace98fbbd18cb635795639d0f22678"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga34ace98fbbd18cb635795639d0f22678"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor6.html">const_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga34ace98fbbd18cb635795639d0f22678">mem_fun6</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)</td></tr>
+<tr class="memdesc:ga34ace98fbbd18cb635795639d0f22678"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor6.html" title="const_mem_functor6 wraps const methods with 6 argument(s).">sigc::const_mem_functor6</a> which wraps a const method. <a href="namespacesigc.html#ga34ace98fbbd18cb635795639d0f22678">More...</a><br /></td></tr>
+<tr class="separator:ga34ace98fbbd18cb635795639d0f22678"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga34ace98fbbd18cb635795639d0f22678"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga34ace98fbbd18cb635795639d0f22678"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor6.html">volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga34ace98fbbd18cb635795639d0f22678">mem_fun6</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)</td></tr>
+<tr class="memdesc:ga34ace98fbbd18cb635795639d0f22678"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor6.html" title="volatile_mem_functor6 wraps volatile methods with 6 argument(s).">sigc::volatile_mem_functor6</a> which wraps a volatile method. <a href="namespacesigc.html#ga34ace98fbbd18cb635795639d0f22678">More...</a><br /></td></tr>
+<tr class="separator:ga34ace98fbbd18cb635795639d0f22678"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga34ace98fbbd18cb635795639d0f22678"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga34ace98fbbd18cb635795639d0f22678"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor6.html">mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga34ace98fbbd18cb635795639d0f22678">mem_fun6</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</td></tr>
+<tr class="memdesc:ga34ace98fbbd18cb635795639d0f22678"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor6.html" title="mem_functor6 wraps methods with 6 argument(s).">sigc::mem_functor6</a> which wraps a method. <a href="group__mem__fun.html#ga34ace98fbbd18cb635795639d0f22678">More...</a><br /></td></tr>
+<tr class="separator:ga34ace98fbbd18cb635795639d0f22678"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga1f704e475da2aad1717e059c264c1436"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga1f704e475da2aad1717e059c264c1436"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">bound_const_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga1f704e475da2aad1717e059c264c1436">mem_fun7</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)</td></tr>
+<tr class="memdesc:ga1f704e475da2aad1717e059c264c1436"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html" title="bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object...">sigc::bound_const_volatile_mem_functor7</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga1f704e475da2aad1717e059c264c1436">More...</a><br /></td></tr>
+<tr class="separator:ga1f704e475da2aad1717e059c264c1436"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga1f704e475da2aad1717e059c264c1436"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga1f704e475da2aad1717e059c264c1436"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html">bound_const_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga1f704e475da2aad1717e059c264c1436">mem_fun7</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)</td></tr>
+<tr class="memdesc:ga1f704e475da2aad1717e059c264c1436"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor7.html" title="bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance.">sigc::bound_const_mem_functor7</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga1f704e475da2aad1717e059c264c1436">More...</a><br /></td></tr>
+<tr class="separator:ga1f704e475da2aad1717e059c264c1436"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga1f704e475da2aad1717e059c264c1436"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga1f704e475da2aad1717e059c264c1436"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">bound_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga1f704e475da2aad1717e059c264c1436">mem_fun7</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)</td></tr>
+<tr class="memdesc:ga1f704e475da2aad1717e059c264c1436"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html" title="bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance.">sigc::bound_volatile_mem_functor7</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga1f704e475da2aad1717e059c264c1436">More...</a><br /></td></tr>
+<tr class="separator:ga1f704e475da2aad1717e059c264c1436"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga1f704e475da2aad1717e059c264c1436"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga1f704e475da2aad1717e059c264c1436"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor7.html">bound_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga1f704e475da2aad1717e059c264c1436">mem_fun7</a> (T_obj & _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</td></tr>
+<tr class="memdesc:ga1f704e475da2aad1717e059c264c1436"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor7.html" title="bound_mem_functor7 encapsulates a method with 7 arguments and an object instance.">sigc::bound_mem_functor7</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga1f704e475da2aad1717e059c264c1436">More...</a><br /></td></tr>
+<tr class="separator:ga1f704e475da2aad1717e059c264c1436"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga9899534bc8eb78c227d895b396710091"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga9899534bc8eb78c227d895b396710091"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">bound_const_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga9899534bc8eb78c227d895b396710091">mem_fun7</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)</td></tr>
+<tr class="memdesc:ga9899534bc8eb78c227d895b396710091"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html" title="bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object...">sigc::bound_const_volatile_mem_functor7</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga9899534bc8eb78c227d895b396710091">More...</a><br /></td></tr>
+<tr class="separator:ga9899534bc8eb78c227d895b396710091"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga9899534bc8eb78c227d895b396710091"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga9899534bc8eb78c227d895b396710091"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html">bound_const_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga9899534bc8eb78c227d895b396710091">mem_fun7</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)</td></tr>
+<tr class="memdesc:ga9899534bc8eb78c227d895b396710091"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor7.html" title="bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance.">sigc::bound_const_mem_functor7</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga9899534bc8eb78c227d895b396710091">More...</a><br /></td></tr>
+<tr class="separator:ga9899534bc8eb78c227d895b396710091"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga9899534bc8eb78c227d895b396710091"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga9899534bc8eb78c227d895b396710091"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">bound_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga9899534bc8eb78c227d895b396710091">mem_fun7</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)</td></tr>
+<tr class="memdesc:ga9899534bc8eb78c227d895b396710091"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html" title="bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance.">sigc::bound_volatile_mem_functor7</a> which encapsulates a method and an object instance. <a href="namespacesigc.html#ga9899534bc8eb78c227d895b396710091">More...</a><br /></td></tr>
+<tr class="separator:ga9899534bc8eb78c227d895b396710091"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga9899534bc8eb78c227d895b396710091"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </td></tr>
+<tr class="memitem:ga9899534bc8eb78c227d895b396710091"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__mem__functor7.html">bound_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga9899534bc8eb78c227d895b396710091">mem_fun7</a> (T_obj * _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</td></tr>
+<tr class="memdesc:ga9899534bc8eb78c227d895b396710091"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1bound__mem__functor7.html" title="bound_mem_functor7 encapsulates a method with 7 arguments and an object instance.">sigc::bound_mem_functor7</a> which encapsulates a method and an object instance. <a href="group__mem__fun.html#ga9899534bc8eb78c227d895b396710091">More...</a><br /></td></tr>
+<tr class="separator:ga9899534bc8eb78c227d895b396710091"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga3d174b01bf94dbda3aea58c25c2b3322"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga3d174b01bf94dbda3aea58c25c2b3322"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">const_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga3d174b01bf94dbda3aea58c25c2b3322">mem_fun7</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)</td></tr>
+<tr class="memdesc:ga3d174b01bf94dbda3aea58c25c2b3322"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html" title="const_volatile_mem_functor7 wraps const volatile methods with 7 argument(s).">sigc::const_volatile_mem_functor7</a> which wraps a const volatile method. <a href="namespacesigc.html#ga3d174b01bf94dbda3aea58c25c2b3322">More...</a><br /></td></tr>
+<tr class="separator:ga3d174b01bf94dbda3aea58c25c2b3322"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga3d174b01bf94dbda3aea58c25c2b3322"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga3d174b01bf94dbda3aea58c25c2b3322"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1const__mem__functor7.html">const_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga3d174b01bf94dbda3aea58c25c2b3322">mem_fun7</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)</td></tr>
+<tr class="memdesc:ga3d174b01bf94dbda3aea58c25c2b3322"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor7.html" title="const_mem_functor7 wraps const methods with 7 argument(s).">sigc::const_mem_functor7</a> which wraps a const method. <a href="namespacesigc.html#ga3d174b01bf94dbda3aea58c25c2b3322">More...</a><br /></td></tr>
+<tr class="separator:ga3d174b01bf94dbda3aea58c25c2b3322"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga3d174b01bf94dbda3aea58c25c2b3322"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga3d174b01bf94dbda3aea58c25c2b3322"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1volatile__mem__functor7.html">volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#ga3d174b01bf94dbda3aea58c25c2b3322">mem_fun7</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)</td></tr>
+<tr class="memdesc:ga3d174b01bf94dbda3aea58c25c2b3322"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor7.html" title="volatile_mem_functor7 wraps volatile methods with 7 argument(s).">sigc::volatile_mem_functor7</a> which wraps a volatile method. <a href="namespacesigc.html#ga3d174b01bf94dbda3aea58c25c2b3322">More...</a><br /></td></tr>
+<tr class="separator:ga3d174b01bf94dbda3aea58c25c2b3322"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga3d174b01bf94dbda3aea58c25c2b3322"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga3d174b01bf94dbda3aea58c25c2b3322"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1mem__functor7.html">mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__mem__fun.html#ga3d174b01bf94dbda3aea58c25c2b3322">mem_fun7</a> (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</td></tr>
+<tr class="memdesc:ga3d174b01bf94dbda3aea58c25c2b3322"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1mem__functor7.html" title="mem_functor7 wraps methods with 7 argument(s).">sigc::mem_functor7</a> which wraps a method. <a href="group__mem__fun.html#ga3d174b01bf94dbda3aea58c25c2b3322">More...</a><br /></td></tr>
+<tr class="separator:ga3d174b01bf94dbda3aea58c25c2b3322"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga9c80de72f656fb05e81fda622dddc863"><td class="memTemplParams" colspan="2">template<class T_return > </td></tr>
+<tr class="memitem:ga9c80de72f656fb05e81fda622dddc863"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor0.html">pointer_functor0</a>< T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863">ptr_fun</a> (T_return(* _A_func)())</td></tr>
+<tr class="memdesc:ga9c80de72f656fb05e81fda622dddc863"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor0.html" title="pointer_functor0 wraps existing non-member functions with 0 argument(s).">sigc::pointer_functor0</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863">More...</a><br /></td></tr>
+<tr class="separator:ga9c80de72f656fb05e81fda622dddc863"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga9b1c3b4ecb24056f5bd38fc6a87f9ad1"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return > </td></tr>
+<tr class="memitem:ga9b1c3b4ecb24056f5bd38fc6a87f9ad1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor1.html">pointer_functor1</a>< T_arg1, T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#ga9b1c3b4ecb24056f5bd38fc6a87f9ad1">ptr_fun</a> (T_return(* _A_func)(T_arg1))</td></tr>
+<tr class="memdesc:ga9b1c3b4ecb24056f5bd38fc6a87f9ad1"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor1.html" title="pointer_functor1 wraps existing non-member functions with 1 argument(s).">sigc::pointer_functor1</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#ga9b1c3b4ecb24056f5bd38fc6a87f9ad1">More...</a><br /></td></tr>
+<tr class="separator:ga9b1c3b4ecb24056f5bd38fc6a87f9ad1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga9c0db14ab1a864b2bad70000325d94c8"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return > </td></tr>
+<tr class="memitem:ga9c0db14ab1a864b2bad70000325d94c8"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor2.html">pointer_functor2</a>< T_arg1, T_arg2, T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#ga9c0db14ab1a864b2bad70000325d94c8">ptr_fun</a> (T_return(* _A_func)(T_arg1, T_arg2))</td></tr>
+<tr class="memdesc:ga9c0db14ab1a864b2bad70000325d94c8"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor2.html" title="pointer_functor2 wraps existing non-member functions with 2 argument(s).">sigc::pointer_functor2</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#ga9c0db14ab1a864b2bad70000325d94c8">More...</a><br /></td></tr>
+<tr class="separator:ga9c0db14ab1a864b2bad70000325d94c8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga1cd2254135f3afcfc5ce34e73cf2f48b"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return > </td></tr>
+<tr class="memitem:ga1cd2254135f3afcfc5ce34e73cf2f48b"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor3.html">pointer_functor3</a>< T_arg1, T_arg2, T_arg3, T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#ga1cd2254135f3afcfc5ce34e73cf2f48b">ptr_fun</a> (T_return(* _A_func)(T_arg1, T_arg2, T_arg3))</td></tr>
+<tr class="memdesc:ga1cd2254135f3afcfc5ce34e73cf2f48b"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor3.html" title="pointer_functor3 wraps existing non-member functions with 3 argument(s).">sigc::pointer_functor3</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#ga1cd2254135f3afcfc5ce34e73cf2f48b">More...</a><br /></td></tr>
+<tr class="separator:ga1cd2254135f3afcfc5ce34e73cf2f48b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaa23ae1abf223560bcac001b86d3cc484"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return > </td></tr>
+<tr class="memitem:gaa23ae1abf223560bcac001b86d3cc484"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor4.html">pointer_functor4</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#gaa23ae1abf223560bcac001b86d3cc484">ptr_fun</a> (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</td></tr>
+<tr class="memdesc:gaa23ae1abf223560bcac001b86d3cc484"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor4.html" title="pointer_functor4 wraps existing non-member functions with 4 argument(s).">sigc::pointer_functor4</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#gaa23ae1abf223560bcac001b86d3cc484">More...</a><br /></td></tr>
+<tr class="separator:gaa23ae1abf223560bcac001b86d3cc484"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gafd3087df10b981325953c93e914d451e"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return > </td></tr>
+<tr class="memitem:gafd3087df10b981325953c93e914d451e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor5.html">pointer_functor5</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#gafd3087df10b981325953c93e914d451e">ptr_fun</a> (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</td></tr>
+<tr class="memdesc:gafd3087df10b981325953c93e914d451e"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor5.html" title="pointer_functor5 wraps existing non-member functions with 5 argument(s).">sigc::pointer_functor5</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#gafd3087df10b981325953c93e914d451e">More...</a><br /></td></tr>
+<tr class="separator:gafd3087df10b981325953c93e914d451e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga0f4d43c3aace56cc5ce0f38886b9ace6"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return > </td></tr>
+<tr class="memitem:ga0f4d43c3aace56cc5ce0f38886b9ace6"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor6.html">pointer_functor6</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#ga0f4d43c3aace56cc5ce0f38886b9ace6">ptr_fun</a> (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</td></tr>
+<tr class="memdesc:ga0f4d43c3aace56cc5ce0f38886b9ace6"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor6.html" title="pointer_functor6 wraps existing non-member functions with 6 argument(s).">sigc::pointer_functor6</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#ga0f4d43c3aace56cc5ce0f38886b9ace6">More...</a><br /></td></tr>
+<tr class="separator:ga0f4d43c3aace56cc5ce0f38886b9ace6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga65221432dda1b020b73349627762da70"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return > </td></tr>
+<tr class="memitem:ga65221432dda1b020b73349627762da70"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor7.html">pointer_functor7</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#ga65221432dda1b020b73349627762da70">ptr_fun</a> (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</td></tr>
+<tr class="memdesc:ga65221432dda1b020b73349627762da70"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor7.html" title="pointer_functor7 wraps existing non-member functions with 7 argument(s).">sigc::pointer_functor7</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#ga65221432dda1b020b73349627762da70">More...</a><br /></td></tr>
+<tr class="separator:ga65221432dda1b020b73349627762da70"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaad8dffc194a4e4dfa0935ce49d43cd5c"><td class="memTemplParams" colspan="2">template<class T_return > </td></tr>
+<tr class="memitem:gaad8dffc194a4e4dfa0935ce49d43cd5c"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor0.html">pointer_functor0</a>< T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#gaad8dffc194a4e4dfa0935ce49d43cd5c">ptr_fun0</a> (T_return(* _A_func)())</td></tr>
+<tr class="memdesc:gaad8dffc194a4e4dfa0935ce49d43cd5c"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor0.html" title="pointer_functor0 wraps existing non-member functions with 0 argument(s).">sigc::pointer_functor0</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#gaad8dffc194a4e4dfa0935ce49d43cd5c">More...</a><br /></td></tr>
+<tr class="separator:gaad8dffc194a4e4dfa0935ce49d43cd5c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga9b1b8e8f5555d6be4ba41be3fb82c94e"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return > </td></tr>
+<tr class="memitem:ga9b1b8e8f5555d6be4ba41be3fb82c94e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor1.html">pointer_functor1</a>< T_arg1, T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#ga9b1b8e8f5555d6be4ba41be3fb82c94e">ptr_fun1</a> (T_return(* _A_func)(T_arg1))</td></tr>
+<tr class="memdesc:ga9b1b8e8f5555d6be4ba41be3fb82c94e"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor1.html" title="pointer_functor1 wraps existing non-member functions with 1 argument(s).">sigc::pointer_functor1</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#ga9b1b8e8f5555d6be4ba41be3fb82c94e">More...</a><br /></td></tr>
+<tr class="separator:ga9b1b8e8f5555d6be4ba41be3fb82c94e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga0244165b83e41a30b2dfb9523afad446"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return > </td></tr>
+<tr class="memitem:ga0244165b83e41a30b2dfb9523afad446"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor2.html">pointer_functor2</a>< T_arg1, T_arg2, T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#ga0244165b83e41a30b2dfb9523afad446">ptr_fun2</a> (T_return(* _A_func)(T_arg1, T_arg2))</td></tr>
+<tr class="memdesc:ga0244165b83e41a30b2dfb9523afad446"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor2.html" title="pointer_functor2 wraps existing non-member functions with 2 argument(s).">sigc::pointer_functor2</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#ga0244165b83e41a30b2dfb9523afad446">More...</a><br /></td></tr>
+<tr class="separator:ga0244165b83e41a30b2dfb9523afad446"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga749e83ea85926d5ad6994d775f98de8d"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return > </td></tr>
+<tr class="memitem:ga749e83ea85926d5ad6994d775f98de8d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor3.html">pointer_functor3</a>< T_arg1, T_arg2, T_arg3, T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#ga749e83ea85926d5ad6994d775f98de8d">ptr_fun3</a> (T_return(* _A_func)(T_arg1, T_arg2, T_arg3))</td></tr>
+<tr class="memdesc:ga749e83ea85926d5ad6994d775f98de8d"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor3.html" title="pointer_functor3 wraps existing non-member functions with 3 argument(s).">sigc::pointer_functor3</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#ga749e83ea85926d5ad6994d775f98de8d">More...</a><br /></td></tr>
+<tr class="separator:ga749e83ea85926d5ad6994d775f98de8d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gac6fa01189c786e778d943a2ee60896a4"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return > </td></tr>
+<tr class="memitem:gac6fa01189c786e778d943a2ee60896a4"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor4.html">pointer_functor4</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#gac6fa01189c786e778d943a2ee60896a4">ptr_fun4</a> (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</td></tr>
+<tr class="memdesc:gac6fa01189c786e778d943a2ee60896a4"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor4.html" title="pointer_functor4 wraps existing non-member functions with 4 argument(s).">sigc::pointer_functor4</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#gac6fa01189c786e778d943a2ee60896a4">More...</a><br /></td></tr>
+<tr class="separator:gac6fa01189c786e778d943a2ee60896a4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga37ae059caefef68e441d3dd7d5b11cce"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return > </td></tr>
+<tr class="memitem:ga37ae059caefef68e441d3dd7d5b11cce"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor5.html">pointer_functor5</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#ga37ae059caefef68e441d3dd7d5b11cce">ptr_fun5</a> (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</td></tr>
+<tr class="memdesc:ga37ae059caefef68e441d3dd7d5b11cce"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor5.html" title="pointer_functor5 wraps existing non-member functions with 5 argument(s).">sigc::pointer_functor5</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#ga37ae059caefef68e441d3dd7d5b11cce">More...</a><br /></td></tr>
+<tr class="separator:ga37ae059caefef68e441d3dd7d5b11cce"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga8cdf17b7ec15b260f5147e1171dd5299"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return > </td></tr>
+<tr class="memitem:ga8cdf17b7ec15b260f5147e1171dd5299"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor6.html">pointer_functor6</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#ga8cdf17b7ec15b260f5147e1171dd5299">ptr_fun6</a> (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</td></tr>
+<tr class="memdesc:ga8cdf17b7ec15b260f5147e1171dd5299"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor6.html" title="pointer_functor6 wraps existing non-member functions with 6 argument(s).">sigc::pointer_functor6</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#ga8cdf17b7ec15b260f5147e1171dd5299">More...</a><br /></td></tr>
+<tr class="separator:ga8cdf17b7ec15b260f5147e1171dd5299"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga82e53ab558dae814c16a09edb53617bb"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return > </td></tr>
+<tr class="memitem:ga82e53ab558dae814c16a09edb53617bb"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1pointer__functor7.html">pointer_functor7</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__ptr__fun.html#ga82e53ab558dae814c16a09edb53617bb">ptr_fun7</a> (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</td></tr>
+<tr class="memdesc:ga82e53ab558dae814c16a09edb53617bb"><td class="mdescLeft"> </td><td class="mdescRight">Creates a functor of type <a class="el" href="classsigc_1_1pointer__functor7.html" title="pointer_functor7 wraps existing non-member functions with 7 argument(s).">sigc::pointer_functor7</a> which wraps an existing non-member function. <a href="group__ptr__fun.html#ga82e53ab558dae814c16a09edb53617bb">More...</a><br /></td></tr>
+<tr class="separator:ga82e53ab558dae814c16a09edb53617bb"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a670882bd3fa5890b464871ac515aaba9"><td class="memTemplParams" colspan="2">template<class T_type > </td></tr>
+<tr class="memitem:a670882bd3fa5890b464871ac515aaba9"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1const__reference__wrapper.html">const_reference_wrapper</a>< T_type > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#a670882bd3fa5890b464871ac515aaba9">ref</a> (const T_type & v)</td></tr>
+<tr class="memdesc:a670882bd3fa5890b464871ac515aaba9"><td class="mdescLeft"> </td><td class="mdescRight">Creates a const reference wrapper. <a href="namespacesigc.html#a670882bd3fa5890b464871ac515aaba9">More...</a><br /></td></tr>
+<tr class="separator:a670882bd3fa5890b464871ac515aaba9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a48e982c74c057b5630246ba436524041"><td class="memTemplParams" colspan="2">template<class T_type > </td></tr>
+<tr class="memitem:a48e982c74c057b5630246ba436524041"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1reference__wrapper.html">reference_wrapper</a>< T_type > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#a48e982c74c057b5630246ba436524041">ref</a> (T_type & v)</td></tr>
+<tr class="memdesc:a48e982c74c057b5630246ba436524041"><td class="mdescLeft"> </td><td class="mdescRight">Creates a reference wrapper. <a href="namespacesigc.html#a48e982c74c057b5630246ba436524041">More...</a><br /></td></tr>
+<tr class="separator:a48e982c74c057b5630246ba436524041"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga31061f134d93297fd0b4f2d56efafbe3"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga31061f134d93297fd0b4f2d56efafbe3"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__mem__functor0.html">bound_const_mem_functor0</a>< T_return, T_obj > > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga31061f134d93297fd0b4f2d56efafbe3">retype</a> (const <a class="el" href="classsigc_1_1bound__const__mem__functor0.html">bound_const_mem_functor0</a>< T_return, T_obj > & _A_functor)</td></tr>
+<tr class="memdesc:ga31061f134d93297fd0b4f2d56efafbe3"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga31061f134d93297fd0b4f2d56efafbe3">More...</a><br /></td></tr>
+<tr class="separator:ga31061f134d93297fd0b4f2d56efafbe3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga63ead6c4883a6553446594e6027dc96c"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 > </td></tr>
+<tr class="memitem:ga63ead6c4883a6553446594e6027dc96c"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__mem__functor1.html">bound_const_mem_functor1</a>< T_return, T_obj, T_arg1 >, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga63ead6c4883a6553446594e6027dc96c">retype</a> (const <a class="el" href="classsigc_1_1bound__const__mem__functor1.html">bound_const_mem_functor1</a>< T_return, T_obj, T_arg1 > & _A_functor)</td></tr>
+<tr class="memdesc:ga63ead6c4883a6553446594e6027dc96c"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga63ead6c4883a6553446594e6027dc96c">More...</a><br /></td></tr>
+<tr class="separator:ga63ead6c4883a6553446594e6027dc96c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga415bd3f44f1785ce30452a4ca8e46dd0"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:ga415bd3f44f1785ce30452a4ca8e46dd0"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__mem__functor2.html">bound_const_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga415bd3f44f1785ce30452a4ca8e46dd0">retype</a> (const <a class="el" href="classsigc_1_1bound__const__mem__functor2.html">bound_const_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > & _A_functor)</td></tr>
+<tr class="memdesc:ga415bd3f44f1785ce30452a4ca8e46dd0"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga415bd3f44f1785ce30452a4ca8e46dd0">More...</a><br /></td></tr>
+<tr class="separator:ga415bd3f44f1785ce30452a4ca8e46dd0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga6f86026b9959cdd62287b29407c71e97"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:ga6f86026b9959cdd62287b29407c71e97"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__mem__functor3.html">bound_const_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga6f86026b9959cdd62287b29407c71e97">retype</a> (const <a class="el" href="classsigc_1_1bound__const__mem__functor3.html">bound_const_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > & _A_functor)</td></tr>
+<tr class="memdesc:ga6f86026b9959cdd62287b29407c71e97"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga6f86026b9959cdd62287b29407c71e97">More...</a><br /></td></tr>
+<tr class="separator:ga6f86026b9959cdd62287b29407c71e97"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga8fbc58cc94f7f4a46c1557091974a278"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:ga8fbc58cc94f7f4a46c1557091974a278"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__mem__functor4.html">bound_const_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga8fbc58cc94f7f4a46c1557091974a278">retype</a> (const <a class="el" href="classsigc_1_1bound__const__mem__functor4.html">bound_const_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > & _A_functor)</td></tr>
+<tr class="memdesc:ga8fbc58cc94f7f4a46c1557091974a278"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga8fbc58cc94f7f4a46c1557091974a278">More...</a><br /></td></tr>
+<tr class="separator:ga8fbc58cc94f7f4a46c1557091974a278"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga1d0d963fa703a6f85b8002c3a405c00a"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:ga1d0d963fa703a6f85b8002c3a405c00a"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__mem__functor5.html">bound_const_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga1d0d963fa703a6f85b8002c3a405c00a">retype</a> (const <a class="el" href="classsigc_1_1bound__const__mem__functor5.html">bound_const_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > & _A_functor)</td></tr>
+<tr class="memdesc:ga1d0d963fa703a6f85b8002c3a405c00a"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga1d0d963fa703a6f85b8002c3a405c00a">More...</a><br /></td></tr>
+<tr class="separator:ga1d0d963fa703a6f85b8002c3a405c00a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga39ba6af86d75de1535e4fa8af1e6081b"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:ga39ba6af86d75de1535e4fa8af1e6081b"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__mem__functor6.html">bound_const_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga39ba6af86d75de1535e4fa8af1e6081b">retype</a> (const <a class="el" href="classsigc_1_1bound__const__mem__functor6.html">bound_const_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > & _A_functor)</td></tr>
+<tr class="memdesc:ga39ba6af86d75de1535e4fa8af1e6081b"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga39ba6af86d75de1535e4fa8af1e6081b">More...</a><br /></td></tr>
+<tr class="separator:ga39ba6af86d75de1535e4fa8af1e6081b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga02a44f2ea2386f8e4fa41cb582c2008d"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:ga02a44f2ea2386f8e4fa41cb582c2008d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__mem__functor7.html">bound_const_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga02a44f2ea2386f8e4fa41cb582c2008d">retype</a> (const <a class="el" href="classsigc_1_1bound__const__mem__functor7.html">bound_const_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & _A_functor)</td></tr>
+<tr class="memdesc:ga02a44f2ea2386f8e4fa41cb582c2008d"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga02a44f2ea2386f8e4fa41cb582c2008d">More...</a><br /></td></tr>
+<tr class="separator:ga02a44f2ea2386f8e4fa41cb582c2008d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gade9ed42b368ea6eee6d42c8116cd28dd"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj > </td></tr>
+<tr class="memitem:gade9ed42b368ea6eee6d42c8116cd28dd"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">bound_const_volatile_mem_functor0</a>< T_return, T_obj > > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gade9ed42b368ea6eee6d42c8116cd28dd">retype</a> (const <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">bound_const_volatile_mem_functor0</a>< T_return, T_obj > & _A_functor)</td></tr>
+<tr class="memdesc:gade9ed42b368ea6eee6d42c8116cd28dd"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gade9ed42b368ea6eee6d42c8116cd28dd">More...</a><br /></td></tr>
+<tr class="separator:gade9ed42b368ea6eee6d42c8116cd28dd"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaab22de279058fd53d5ef720ad3932b56"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 > </td></tr>
+<tr class="memitem:gaab22de279058fd53d5ef720ad3932b56"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">bound_const_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gaab22de279058fd53d5ef720ad3932b56">retype</a> (const <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">bound_const_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 > & _A_functor)</td></tr>
+<tr class="memdesc:gaab22de279058fd53d5ef720ad3932b56"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gaab22de279058fd53d5ef720ad3932b56">More...</a><br /></td></tr>
+<tr class="separator:gaab22de279058fd53d5ef720ad3932b56"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga42f7c6ae10273b6577909f89bd76dc1f"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:ga42f7c6ae10273b6577909f89bd76dc1f"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">bound_const_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga42f7c6ae10273b6577909f89bd76dc1f">retype</a> (const <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">bound_const_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > & _A_functor)</td></tr>
+<tr class="memdesc:ga42f7c6ae10273b6577909f89bd76dc1f"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga42f7c6ae10273b6577909f89bd76dc1f">More...</a><br /></td></tr>
+<tr class="separator:ga42f7c6ae10273b6577909f89bd76dc1f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga1b2477c6ed3347fae35c66f25977f9dc"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:ga1b2477c6ed3347fae35c66f25977f9dc"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">bound_const_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga1b2477c6ed3347fae35c66f25977f9dc">retype</a> (const <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">bound_const_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > & _A_functor)</td></tr>
+<tr class="memdesc:ga1b2477c6ed3347fae35c66f25977f9dc"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga1b2477c6ed3347fae35c66f25977f9dc">More...</a><br /></td></tr>
+<tr class="separator:ga1b2477c6ed3347fae35c66f25977f9dc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gad73b9445fab1544d7550db964426520d"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:gad73b9445fab1544d7550db964426520d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">bound_const_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gad73b9445fab1544d7550db964426520d">retype</a> (const <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">bound_const_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > & _A_functor)</td></tr>
+<tr class="memdesc:gad73b9445fab1544d7550db964426520d"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gad73b9445fab1544d7550db964426520d">More...</a><br /></td></tr>
+<tr class="separator:gad73b9445fab1544d7550db964426520d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gacbb4a1e1c3447205bf507d6912847015"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:gacbb4a1e1c3447205bf507d6912847015"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">bound_const_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gacbb4a1e1c3447205bf507d6912847015">retype</a> (const <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">bound_const_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > & _A_functor)</td></tr>
+<tr class="memdesc:gacbb4a1e1c3447205bf507d6912847015"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gacbb4a1e1c3447205bf507d6912847015">More...</a><br /></td></tr>
+<tr class="separator:gacbb4a1e1c3447205bf507d6912847015"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gace1ef4f9ca35373adaad3c29db2b918f"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:gace1ef4f9ca35373adaad3c29db2b918f"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">bound_const_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gace1ef4f9ca35373adaad3c29db2b918f">retype</a> (const <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">bound_const_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > & _A_functor)</td></tr>
+<tr class="memdesc:gace1ef4f9ca35373adaad3c29db2b918f"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gace1ef4f9ca35373adaad3c29db2b918f">More...</a><br /></td></tr>
+<tr class="separator:gace1ef4f9ca35373adaad3c29db2b918f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga1ec0f19b59050f8f01c8969835b3c742"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:ga1ec0f19b59050f8f01c8969835b3c742"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">bound_const_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga1ec0f19b59050f8f01c8969835b3c742">retype</a> (const <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">bound_const_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & _A_functor)</td></tr>
+<tr class="memdesc:ga1ec0f19b59050f8f01c8969835b3c742"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga1ec0f19b59050f8f01c8969835b3c742">More...</a><br /></td></tr>
+<tr class="separator:ga1ec0f19b59050f8f01c8969835b3c742"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaebe9c150af92e230257bbbdb728e5a07"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj > </td></tr>
+<tr class="memitem:gaebe9c150af92e230257bbbdb728e5a07"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__mem__functor0.html">bound_mem_functor0</a>< T_return, T_obj > > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gaebe9c150af92e230257bbbdb728e5a07">retype</a> (const <a class="el" href="classsigc_1_1bound__mem__functor0.html">bound_mem_functor0</a>< T_return, T_obj > & _A_functor)</td></tr>
+<tr class="memdesc:gaebe9c150af92e230257bbbdb728e5a07"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gaebe9c150af92e230257bbbdb728e5a07">More...</a><br /></td></tr>
+<tr class="separator:gaebe9c150af92e230257bbbdb728e5a07"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga971017d74a880ee10555ebd32483d188"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 > </td></tr>
+<tr class="memitem:ga971017d74a880ee10555ebd32483d188"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__mem__functor1.html">bound_mem_functor1</a>< T_return, T_obj, T_arg1 >, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga971017d74a880ee10555ebd32483d188">retype</a> (const <a class="el" href="classsigc_1_1bound__mem__functor1.html">bound_mem_functor1</a>< T_return, T_obj, T_arg1 > & _A_functor)</td></tr>
+<tr class="memdesc:ga971017d74a880ee10555ebd32483d188"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga971017d74a880ee10555ebd32483d188">More...</a><br /></td></tr>
+<tr class="separator:ga971017d74a880ee10555ebd32483d188"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaddf62506fc01f1cdfcadef27e47f9b59"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:gaddf62506fc01f1cdfcadef27e47f9b59"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__mem__functor2.html">bound_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gaddf62506fc01f1cdfcadef27e47f9b59">retype</a> (const <a class="el" href="classsigc_1_1bound__mem__functor2.html">bound_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > & _A_functor)</td></tr>
+<tr class="memdesc:gaddf62506fc01f1cdfcadef27e47f9b59"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gaddf62506fc01f1cdfcadef27e47f9b59">More...</a><br /></td></tr>
+<tr class="separator:gaddf62506fc01f1cdfcadef27e47f9b59"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gad916eb17d984df3b7da9b7d3d041168a"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:gad916eb17d984df3b7da9b7d3d041168a"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__mem__functor3.html">bound_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gad916eb17d984df3b7da9b7d3d041168a">retype</a> (const <a class="el" href="classsigc_1_1bound__mem__functor3.html">bound_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > & _A_functor)</td></tr>
+<tr class="memdesc:gad916eb17d984df3b7da9b7d3d041168a"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gad916eb17d984df3b7da9b7d3d041168a">More...</a><br /></td></tr>
+<tr class="separator:gad916eb17d984df3b7da9b7d3d041168a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga8362fa71a99b71b843205e0482b281fc"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:ga8362fa71a99b71b843205e0482b281fc"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__mem__functor4.html">bound_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga8362fa71a99b71b843205e0482b281fc">retype</a> (const <a class="el" href="classsigc_1_1bound__mem__functor4.html">bound_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > & _A_functor)</td></tr>
+<tr class="memdesc:ga8362fa71a99b71b843205e0482b281fc"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga8362fa71a99b71b843205e0482b281fc">More...</a><br /></td></tr>
+<tr class="separator:ga8362fa71a99b71b843205e0482b281fc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga9c139b3254f5020de44a73c7dd795819"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:ga9c139b3254f5020de44a73c7dd795819"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__mem__functor5.html">bound_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga9c139b3254f5020de44a73c7dd795819">retype</a> (const <a class="el" href="classsigc_1_1bound__mem__functor5.html">bound_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > & _A_functor)</td></tr>
+<tr class="memdesc:ga9c139b3254f5020de44a73c7dd795819"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga9c139b3254f5020de44a73c7dd795819">More...</a><br /></td></tr>
+<tr class="separator:ga9c139b3254f5020de44a73c7dd795819"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga12e152b4340f83bd1f6cec92771fa82a"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:ga12e152b4340f83bd1f6cec92771fa82a"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__mem__functor6.html">bound_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga12e152b4340f83bd1f6cec92771fa82a">retype</a> (const <a class="el" href="classsigc_1_1bound__mem__functor6.html">bound_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > & _A_functor)</td></tr>
+<tr class="memdesc:ga12e152b4340f83bd1f6cec92771fa82a"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga12e152b4340f83bd1f6cec92771fa82a">More...</a><br /></td></tr>
+<tr class="separator:ga12e152b4340f83bd1f6cec92771fa82a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gadda8029b543d9b657f01e6ba9a9ef8fd"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:gadda8029b543d9b657f01e6ba9a9ef8fd"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__mem__functor7.html">bound_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gadda8029b543d9b657f01e6ba9a9ef8fd">retype</a> (const <a class="el" href="classsigc_1_1bound__mem__functor7.html">bound_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & _A_functor)</td></tr>
+<tr class="memdesc:gadda8029b543d9b657f01e6ba9a9ef8fd"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gadda8029b543d9b657f01e6ba9a9ef8fd">More...</a><br /></td></tr>
+<tr class="separator:gadda8029b543d9b657f01e6ba9a9ef8fd"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gadc01bb77132048902ec8965d012edcd3"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj > </td></tr>
+<tr class="memitem:gadc01bb77132048902ec8965d012edcd3"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">bound_volatile_mem_functor0</a>< T_return, T_obj > > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gadc01bb77132048902ec8965d012edcd3">retype</a> (const <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">bound_volatile_mem_functor0</a>< T_return, T_obj > & _A_functor)</td></tr>
+<tr class="memdesc:gadc01bb77132048902ec8965d012edcd3"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gadc01bb77132048902ec8965d012edcd3">More...</a><br /></td></tr>
+<tr class="separator:gadc01bb77132048902ec8965d012edcd3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga45b921820c277072b6f7e856ddbcfca1"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 > </td></tr>
+<tr class="memitem:ga45b921820c277072b6f7e856ddbcfca1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">bound_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga45b921820c277072b6f7e856ddbcfca1">retype</a> (const <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">bound_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 > & _A_functor)</td></tr>
+<tr class="memdesc:ga45b921820c277072b6f7e856ddbcfca1"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga45b921820c277072b6f7e856ddbcfca1">More...</a><br /></td></tr>
+<tr class="separator:ga45b921820c277072b6f7e856ddbcfca1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaf420d79b4077b848ef1aef4b68810d6e"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:gaf420d79b4077b848ef1aef4b68810d6e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">bound_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gaf420d79b4077b848ef1aef4b68810d6e">retype</a> (const <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">bound_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > & _A_functor)</td></tr>
+<tr class="memdesc:gaf420d79b4077b848ef1aef4b68810d6e"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gaf420d79b4077b848ef1aef4b68810d6e">More...</a><br /></td></tr>
+<tr class="separator:gaf420d79b4077b848ef1aef4b68810d6e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga899ae79da0e918ad9fc8f2c8e8066218"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:ga899ae79da0e918ad9fc8f2c8e8066218"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">bound_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga899ae79da0e918ad9fc8f2c8e8066218">retype</a> (const <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">bound_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > & _A_functor)</td></tr>
+<tr class="memdesc:ga899ae79da0e918ad9fc8f2c8e8066218"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga899ae79da0e918ad9fc8f2c8e8066218">More...</a><br /></td></tr>
+<tr class="separator:ga899ae79da0e918ad9fc8f2c8e8066218"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga8540037bfd4da57495b60dd9487c6d0b"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:ga8540037bfd4da57495b60dd9487c6d0b"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">bound_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga8540037bfd4da57495b60dd9487c6d0b">retype</a> (const <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">bound_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > & _A_functor)</td></tr>
+<tr class="memdesc:ga8540037bfd4da57495b60dd9487c6d0b"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga8540037bfd4da57495b60dd9487c6d0b">More...</a><br /></td></tr>
+<tr class="separator:ga8540037bfd4da57495b60dd9487c6d0b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga31ace8220cbb70b8e7f545ee4c1b6610"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:ga31ace8220cbb70b8e7f545ee4c1b6610"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">bound_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga31ace8220cbb70b8e7f545ee4c1b6610">retype</a> (const <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">bound_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > & _A_functor)</td></tr>
+<tr class="memdesc:ga31ace8220cbb70b8e7f545ee4c1b6610"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga31ace8220cbb70b8e7f545ee4c1b6610">More...</a><br /></td></tr>
+<tr class="separator:ga31ace8220cbb70b8e7f545ee4c1b6610"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga9f45f05c95abc9d20ae9d39589f5d72e"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:ga9f45f05c95abc9d20ae9d39589f5d72e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">bound_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga9f45f05c95abc9d20ae9d39589f5d72e">retype</a> (const <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">bound_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > & _A_functor)</td></tr>
+<tr class="memdesc:ga9f45f05c95abc9d20ae9d39589f5d72e"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga9f45f05c95abc9d20ae9d39589f5d72e">More...</a><br /></td></tr>
+<tr class="separator:ga9f45f05c95abc9d20ae9d39589f5d72e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga17e8761db2fafa2d3a92d19d8ce47511"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:ga17e8761db2fafa2d3a92d19d8ce47511"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">bound_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga17e8761db2fafa2d3a92d19d8ce47511">retype</a> (const <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">bound_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & _A_functor)</td></tr>
+<tr class="memdesc:ga17e8761db2fafa2d3a92d19d8ce47511"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga17e8761db2fafa2d3a92d19d8ce47511">More...</a><br /></td></tr>
+<tr class="separator:ga17e8761db2fafa2d3a92d19d8ce47511"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga0688ca8eb3ee82e191563ba7f81366b2"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga0688ca8eb3ee82e191563ba7f81366b2"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__mem__functor0.html">const_mem_functor0</a>< T_return, T_obj > > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga0688ca8eb3ee82e191563ba7f81366b2">retype</a> (const <a class="el" href="classsigc_1_1const__mem__functor0.html">const_mem_functor0</a>< T_return, T_obj > & _A_functor)</td></tr>
+<tr class="memdesc:ga0688ca8eb3ee82e191563ba7f81366b2"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga0688ca8eb3ee82e191563ba7f81366b2">More...</a><br /></td></tr>
+<tr class="separator:ga0688ca8eb3ee82e191563ba7f81366b2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gae035134414ed79a187a6b41a115a3759"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 > </td></tr>
+<tr class="memitem:gae035134414ed79a187a6b41a115a3759"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__mem__functor1.html">const_mem_functor1</a>< T_return, T_obj, T_arg1 >, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gae035134414ed79a187a6b41a115a3759">retype</a> (const <a class="el" href="classsigc_1_1const__mem__functor1.html">const_mem_functor1</a>< T_return, T_obj, T_arg1 > & _A_functor)</td></tr>
+<tr class="memdesc:gae035134414ed79a187a6b41a115a3759"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gae035134414ed79a187a6b41a115a3759">More...</a><br /></td></tr>
+<tr class="separator:gae035134414ed79a187a6b41a115a3759"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga8e9ee582f601451f3aa7c3d37d03b952"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:ga8e9ee582f601451f3aa7c3d37d03b952"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__mem__functor2.html">const_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga8e9ee582f601451f3aa7c3d37d03b952">retype</a> (const <a class="el" href="classsigc_1_1const__mem__functor2.html">const_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > & _A_functor)</td></tr>
+<tr class="memdesc:ga8e9ee582f601451f3aa7c3d37d03b952"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga8e9ee582f601451f3aa7c3d37d03b952">More...</a><br /></td></tr>
+<tr class="separator:ga8e9ee582f601451f3aa7c3d37d03b952"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga81e06b857f7a44b0589125e28535f87f"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:ga81e06b857f7a44b0589125e28535f87f"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__mem__functor3.html">const_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga81e06b857f7a44b0589125e28535f87f">retype</a> (const <a class="el" href="classsigc_1_1const__mem__functor3.html">const_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > & _A_functor)</td></tr>
+<tr class="memdesc:ga81e06b857f7a44b0589125e28535f87f"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga81e06b857f7a44b0589125e28535f87f">More...</a><br /></td></tr>
+<tr class="separator:ga81e06b857f7a44b0589125e28535f87f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga411bdd3476f80d627c50d47149862ec2"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:ga411bdd3476f80d627c50d47149862ec2"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__mem__functor4.html">const_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga411bdd3476f80d627c50d47149862ec2">retype</a> (const <a class="el" href="classsigc_1_1const__mem__functor4.html">const_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > & _A_functor)</td></tr>
+<tr class="memdesc:ga411bdd3476f80d627c50d47149862ec2"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga411bdd3476f80d627c50d47149862ec2">More...</a><br /></td></tr>
+<tr class="separator:ga411bdd3476f80d627c50d47149862ec2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga995053759ee8ee89663f9625a4aaf596"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:ga995053759ee8ee89663f9625a4aaf596"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__mem__functor5.html">const_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga995053759ee8ee89663f9625a4aaf596">retype</a> (const <a class="el" href="classsigc_1_1const__mem__functor5.html">const_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > & _A_functor)</td></tr>
+<tr class="memdesc:ga995053759ee8ee89663f9625a4aaf596"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga995053759ee8ee89663f9625a4aaf596">More...</a><br /></td></tr>
+<tr class="separator:ga995053759ee8ee89663f9625a4aaf596"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga851188153c54bb1eb8fee425f9796981"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:ga851188153c54bb1eb8fee425f9796981"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__mem__functor6.html">const_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga851188153c54bb1eb8fee425f9796981">retype</a> (const <a class="el" href="classsigc_1_1const__mem__functor6.html">const_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > & _A_functor)</td></tr>
+<tr class="memdesc:ga851188153c54bb1eb8fee425f9796981"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga851188153c54bb1eb8fee425f9796981">More...</a><br /></td></tr>
+<tr class="separator:ga851188153c54bb1eb8fee425f9796981"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaa951debcabd066f8c3479617aaa9689e"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:gaa951debcabd066f8c3479617aaa9689e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__mem__functor7.html">const_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gaa951debcabd066f8c3479617aaa9689e">retype</a> (const <a class="el" href="classsigc_1_1const__mem__functor7.html">const_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & _A_functor)</td></tr>
+<tr class="memdesc:gaa951debcabd066f8c3479617aaa9689e"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gaa951debcabd066f8c3479617aaa9689e">More...</a><br /></td></tr>
+<tr class="separator:gaa951debcabd066f8c3479617aaa9689e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga312fca59eb8b4ca0e078b1cf7f407212"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga312fca59eb8b4ca0e078b1cf7f407212"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">const_volatile_mem_functor0</a>< T_return, T_obj > > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga312fca59eb8b4ca0e078b1cf7f407212">retype</a> (const <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">const_volatile_mem_functor0</a>< T_return, T_obj > & _A_functor)</td></tr>
+<tr class="memdesc:ga312fca59eb8b4ca0e078b1cf7f407212"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga312fca59eb8b4ca0e078b1cf7f407212">More...</a><br /></td></tr>
+<tr class="separator:ga312fca59eb8b4ca0e078b1cf7f407212"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga84f4247ab4cc559aed835ccd943fab70"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 > </td></tr>
+<tr class="memitem:ga84f4247ab4cc559aed835ccd943fab70"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">const_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga84f4247ab4cc559aed835ccd943fab70">retype</a> (const <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">const_volatile_mem_functor1</a>< T_return, T_obj, T_arg1 > & _A_functor)</td></tr>
+<tr class="memdesc:ga84f4247ab4cc559aed835ccd943fab70"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga84f4247ab4cc559aed835ccd943fab70">More...</a><br /></td></tr>
+<tr class="separator:ga84f4247ab4cc559aed835ccd943fab70"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga271911579dfbac317a53f62f0773e420"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:ga271911579dfbac317a53f62f0773e420"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">const_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga271911579dfbac317a53f62f0773e420">retype</a> (const <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">const_volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > & _A_functor)</td></tr>
+<tr class="memdesc:ga271911579dfbac317a53f62f0773e420"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga271911579dfbac317a53f62f0773e420">More...</a><br /></td></tr>
+<tr class="separator:ga271911579dfbac317a53f62f0773e420"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga97b4f14b5a7991eba60b635871d6a7f9"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:ga97b4f14b5a7991eba60b635871d6a7f9"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">const_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga97b4f14b5a7991eba60b635871d6a7f9">retype</a> (const <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">const_volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > & _A_functor)</td></tr>
+<tr class="memdesc:ga97b4f14b5a7991eba60b635871d6a7f9"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga97b4f14b5a7991eba60b635871d6a7f9">More...</a><br /></td></tr>
+<tr class="separator:ga97b4f14b5a7991eba60b635871d6a7f9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga4e9179cc61db0069db209bc7632b3dee"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:ga4e9179cc61db0069db209bc7632b3dee"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">const_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga4e9179cc61db0069db209bc7632b3dee">retype</a> (const <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">const_volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > & _A_functor)</td></tr>
+<tr class="memdesc:ga4e9179cc61db0069db209bc7632b3dee"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga4e9179cc61db0069db209bc7632b3dee">More...</a><br /></td></tr>
+<tr class="separator:ga4e9179cc61db0069db209bc7632b3dee"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga637af7b3e60f5657dcd62e350ec76675"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:ga637af7b3e60f5657dcd62e350ec76675"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">const_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga637af7b3e60f5657dcd62e350ec76675">retype</a> (const <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">const_volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > & _A_functor)</td></tr>
+<tr class="memdesc:ga637af7b3e60f5657dcd62e350ec76675"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga637af7b3e60f5657dcd62e350ec76675">More...</a><br /></td></tr>
+<tr class="separator:ga637af7b3e60f5657dcd62e350ec76675"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga17ceafe96cdf3bd37ccd401f413f8748"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:ga17ceafe96cdf3bd37ccd401f413f8748"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">const_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga17ceafe96cdf3bd37ccd401f413f8748">retype</a> (const <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">const_volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > & _A_functor)</td></tr>
+<tr class="memdesc:ga17ceafe96cdf3bd37ccd401f413f8748"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga17ceafe96cdf3bd37ccd401f413f8748">More...</a><br /></td></tr>
+<tr class="separator:ga17ceafe96cdf3bd37ccd401f413f8748"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga75578233ce4f47c5f610569a5ffe84cc"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:ga75578233ce4f47c5f610569a5ffe84cc"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">const_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga75578233ce4f47c5f610569a5ffe84cc">retype</a> (const <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">const_volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & _A_functor)</td></tr>
+<tr class="memdesc:ga75578233ce4f47c5f610569a5ffe84cc"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga75578233ce4f47c5f610569a5ffe84cc">More...</a><br /></td></tr>
+<tr class="separator:ga75578233ce4f47c5f610569a5ffe84cc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gabb08dd87f3ec392536b656b6b3e959a0"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj > </td></tr>
+<tr class="memitem:gabb08dd87f3ec392536b656b6b3e959a0"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1mem__functor0.html">mem_functor0</a>< T_return, T_obj > > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gabb08dd87f3ec392536b656b6b3e959a0">retype</a> (const <a class="el" href="classsigc_1_1mem__functor0.html">mem_functor0</a>< T_return, T_obj > & _A_functor)</td></tr>
+<tr class="memdesc:gabb08dd87f3ec392536b656b6b3e959a0"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gabb08dd87f3ec392536b656b6b3e959a0">More...</a><br /></td></tr>
+<tr class="separator:gabb08dd87f3ec392536b656b6b3e959a0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga5a2600190453d4eb11c14f99973044bc"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 > </td></tr>
+<tr class="memitem:ga5a2600190453d4eb11c14f99973044bc"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1mem__functor1.html">mem_functor1</a>< T_return, T_obj, T_arg1 >, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga5a2600190453d4eb11c14f99973044bc">retype</a> (const <a class="el" href="classsigc_1_1mem__functor1.html">mem_functor1</a>< T_return, T_obj, T_arg1 > & _A_functor)</td></tr>
+<tr class="memdesc:ga5a2600190453d4eb11c14f99973044bc"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga5a2600190453d4eb11c14f99973044bc">More...</a><br /></td></tr>
+<tr class="separator:ga5a2600190453d4eb11c14f99973044bc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga7df338186f09b1c89c2840f6744362e9"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:ga7df338186f09b1c89c2840f6744362e9"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1mem__functor2.html">mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga7df338186f09b1c89c2840f6744362e9">retype</a> (const <a class="el" href="classsigc_1_1mem__functor2.html">mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > & _A_functor)</td></tr>
+<tr class="memdesc:ga7df338186f09b1c89c2840f6744362e9"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga7df338186f09b1c89c2840f6744362e9">More...</a><br /></td></tr>
+<tr class="separator:ga7df338186f09b1c89c2840f6744362e9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gae2d9d2e91b2f8d256e4ad8da1c3c59e0"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:gae2d9d2e91b2f8d256e4ad8da1c3c59e0"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1mem__functor3.html">mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gae2d9d2e91b2f8d256e4ad8da1c3c59e0">retype</a> (const <a class="el" href="classsigc_1_1mem__functor3.html">mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > & _A_functor)</td></tr>
+<tr class="memdesc:gae2d9d2e91b2f8d256e4ad8da1c3c59e0"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gae2d9d2e91b2f8d256e4ad8da1c3c59e0">More...</a><br /></td></tr>
+<tr class="separator:gae2d9d2e91b2f8d256e4ad8da1c3c59e0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga70e615639e07e90a997a378cf877b106"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:ga70e615639e07e90a997a378cf877b106"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1mem__functor4.html">mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga70e615639e07e90a997a378cf877b106">retype</a> (const <a class="el" href="classsigc_1_1mem__functor4.html">mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > & _A_functor)</td></tr>
+<tr class="memdesc:ga70e615639e07e90a997a378cf877b106"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga70e615639e07e90a997a378cf877b106">More...</a><br /></td></tr>
+<tr class="separator:ga70e615639e07e90a997a378cf877b106"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gad225dee1d71c68d0ee71f3f0fedcfc1b"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:gad225dee1d71c68d0ee71f3f0fedcfc1b"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1mem__functor5.html">mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gad225dee1d71c68d0ee71f3f0fedcfc1b">retype</a> (const <a class="el" href="classsigc_1_1mem__functor5.html">mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > & _A_functor)</td></tr>
+<tr class="memdesc:gad225dee1d71c68d0ee71f3f0fedcfc1b"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gad225dee1d71c68d0ee71f3f0fedcfc1b">More...</a><br /></td></tr>
+<tr class="separator:gad225dee1d71c68d0ee71f3f0fedcfc1b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga9c08fe50076854f15c923ab4183aed0f"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:ga9c08fe50076854f15c923ab4183aed0f"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1mem__functor6.html">mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga9c08fe50076854f15c923ab4183aed0f">retype</a> (const <a class="el" href="classsigc_1_1mem__functor6.html">mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > & _A_functor)</td></tr>
+<tr class="memdesc:ga9c08fe50076854f15c923ab4183aed0f"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga9c08fe50076854f15c923ab4183aed0f">More...</a><br /></td></tr>
+<tr class="separator:ga9c08fe50076854f15c923ab4183aed0f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga3fbd72b71a4ea4fafa487b5932acd797"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:ga3fbd72b71a4ea4fafa487b5932acd797"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1mem__functor7.html">mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga3fbd72b71a4ea4fafa487b5932acd797">retype</a> (const <a class="el" href="classsigc_1_1mem__functor7.html">mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & _A_functor)</td></tr>
+<tr class="memdesc:ga3fbd72b71a4ea4fafa487b5932acd797"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga3fbd72b71a4ea4fafa487b5932acd797">More...</a><br /></td></tr>
+<tr class="separator:ga3fbd72b71a4ea4fafa487b5932acd797"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga23978c94d9d3c934803898c3bf48ff7d"><td class="memTemplParams" colspan="2">template<class T_return > </td></tr>
+<tr class="memitem:ga23978c94d9d3c934803898c3bf48ff7d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1pointer__functor0.html">pointer_functor0</a>< T_return > > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga23978c94d9d3c934803898c3bf48ff7d">retype</a> (const <a class="el" href="classsigc_1_1pointer__functor0.html">pointer_functor0</a>< T_return > & _A_functor)</td></tr>
+<tr class="memdesc:ga23978c94d9d3c934803898c3bf48ff7d"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga23978c94d9d3c934803898c3bf48ff7d">More...</a><br /></td></tr>
+<tr class="separator:ga23978c94d9d3c934803898c3bf48ff7d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga75cc92c15faf06d5293ff34179f21899"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_return > </td></tr>
+<tr class="memitem:ga75cc92c15faf06d5293ff34179f21899"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1pointer__functor1.html">pointer_functor1</a>< T_arg1, T_return >, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga75cc92c15faf06d5293ff34179f21899">retype</a> (const <a class="el" href="classsigc_1_1pointer__functor1.html">pointer_functor1</a>< T_arg1, T_return > & _A_functor)</td></tr>
+<tr class="memdesc:ga75cc92c15faf06d5293ff34179f21899"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga75cc92c15faf06d5293ff34179f21899">More...</a><br /></td></tr>
+<tr class="separator:ga75cc92c15faf06d5293ff34179f21899"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga0d67e207b3d753ab71b3801981cfeff3"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_return > </td></tr>
+<tr class="memitem:ga0d67e207b3d753ab71b3801981cfeff3"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1pointer__functor2.html">pointer_functor2</a>< T_arg1, T_arg2, T_return >, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga0d67e207b3d753ab71b3801981cfeff3">retype</a> (const <a class="el" href="classsigc_1_1pointer__functor2.html">pointer_functor2</a>< T_arg1, T_arg2, T_return > & _A_functor)</td></tr>
+<tr class="memdesc:ga0d67e207b3d753ab71b3801981cfeff3"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga0d67e207b3d753ab71b3801981cfeff3">More...</a><br /></td></tr>
+<tr class="separator:ga0d67e207b3d753ab71b3801981cfeff3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaa5dfa926e3bfc7b82e0d14e4d9c9ff32"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_return > </td></tr>
+<tr class="memitem:gaa5dfa926e3bfc7b82e0d14e4d9c9ff32"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1pointer__functor3.html">pointer_functor3</a>< T_arg1, T_arg2, T_arg3, T_return >, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gaa5dfa926e3bfc7b82e0d14e4d9c9ff32">retype</a> (const <a class="el" href="classsigc_1_1pointer__functor3.html">pointer_functor3</a>< T_arg1, T_arg2, T_arg3, T_return > & _A_functor)</td></tr>
+<tr class="memdesc:gaa5dfa926e3bfc7b82e0d14e4d9c9ff32"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gaa5dfa926e3bfc7b82e0d14e4d9c9ff32">More...</a><br /></td></tr>
+<tr class="separator:gaa5dfa926e3bfc7b82e0d14e4d9c9ff32"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gade02a3d76cf35465acfa39d4e03a40d5"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return > </td></tr>
+<tr class="memitem:gade02a3d76cf35465acfa39d4e03a40d5"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1pointer__functor4.html">pointer_functor4</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_return >, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#gade02a3d76cf35465acfa39d4e03a40d5">retype</a> (const <a class="el" href="classsigc_1_1pointer__functor4.html">pointer_functor4</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_return > & _A_functor)</td></tr>
+<tr class="memdesc:gade02a3d76cf35465acfa39d4e03a40d5"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#gade02a3d76cf35465acfa39d4e03a40d5">More...</a><br /></td></tr>
+<tr class="separator:gade02a3d76cf35465acfa39d4e03a40d5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga45fa726d6497c6b0994444fd2569581c"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return > </td></tr>
+<tr class="memitem:ga45fa726d6497c6b0994444fd2569581c"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1pointer__functor5.html">pointer_functor5</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga45fa726d6497c6b0994444fd2569581c">retype</a> (const <a class="el" href="classsigc_1_1pointer__functor5.html">pointer_functor5</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return > & _A_functor)</td></tr>
+<tr class="memdesc:ga45fa726d6497c6b0994444fd2569581c"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga45fa726d6497c6b0994444fd2569581c">More...</a><br /></td></tr>
+<tr class="separator:ga45fa726d6497c6b0994444fd2569581c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga24e30de09c3784220829f52bb068b8c0"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return > </td></tr>
+<tr class="memitem:ga24e30de09c3784220829f52bb068b8c0"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1pointer__functor6.html">pointer_functor6</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga24e30de09c3784220829f52bb068b8c0">retype</a> (const <a class="el" href="classsigc_1_1pointer__functor6.html">pointer_functor6</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return > & _A_functor)</td></tr>
+<tr class="memdesc:ga24e30de09c3784220829f52bb068b8c0"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga24e30de09c3784220829f52bb068b8c0">More...</a><br /></td></tr>
+<tr class="separator:ga24e30de09c3784220829f52bb068b8c0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga09db0b458651a7fcd985e5dd4e50caa0"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return > </td></tr>
+<tr class="memitem:ga09db0b458651a7fcd985e5dd4e50caa0"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1pointer__functor7.html">pointer_functor7</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga09db0b458651a7fcd985e5dd4e50caa0">retype</a> (const <a class="el" href="classsigc_1_1pointer__functor7.html">pointer_functor7</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return > & _A_functor)</td></tr>
+<tr class="memdesc:ga09db0b458651a7fcd985e5dd4e50caa0"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga09db0b458651a7fcd985e5dd4e50caa0">More...</a><br /></td></tr>
+<tr class="separator:ga09db0b458651a7fcd985e5dd4e50caa0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga8b98eeb2a61b5b1f84dcd1d20fe666f1"><td class="memTemplParams" colspan="2">template<class T_return , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:ga8b98eeb2a61b5b1f84dcd1d20fe666f1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga8b98eeb2a61b5b1f84dcd1d20fe666f1">retype</a> (const <a class="el" href="classsigc_1_1slot.html">slot</a>< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & _A_functor)</td></tr>
+<tr class="memdesc:ga8b98eeb2a61b5b1f84dcd1d20fe666f1"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga8b98eeb2a61b5b1f84dcd1d20fe666f1">More...</a><br /></td></tr>
+<tr class="separator:ga8b98eeb2a61b5b1f84dcd1d20fe666f1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga53d620659c82cbb84da3812ac874f4b7"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj > </td></tr>
+<tr class="memitem:ga53d620659c82cbb84da3812ac874f4b7"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1volatile__mem__functor0.html">volatile_mem_functor0</a>< T_return, T_obj > > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga53d620659c82cbb84da3812ac874f4b7">retype</a> (const <a class="el" href="classsigc_1_1volatile__mem__functor0.html">volatile_mem_functor0</a>< T_return, T_obj > & _A_functor)</td></tr>
+<tr class="memdesc:ga53d620659c82cbb84da3812ac874f4b7"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga53d620659c82cbb84da3812ac874f4b7">More...</a><br /></td></tr>
+<tr class="separator:ga53d620659c82cbb84da3812ac874f4b7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga6d7f05b930056183bc7537447c80e59b"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 > </td></tr>
+<tr class="memitem:ga6d7f05b930056183bc7537447c80e59b"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1volatile__mem__functor1.html">volatile_mem_functor1</a>< T_return, T_obj, T_arg1 >, T_arg1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga6d7f05b930056183bc7537447c80e59b">retype</a> (const <a class="el" href="classsigc_1_1volatile__mem__functor1.html">volatile_mem_functor1</a>< T_return, T_obj, T_arg1 > & _A_functor)</td></tr>
+<tr class="memdesc:ga6d7f05b930056183bc7537447c80e59b"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga6d7f05b930056183bc7537447c80e59b">More...</a><br /></td></tr>
+<tr class="separator:ga6d7f05b930056183bc7537447c80e59b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga5b65e9a9794300c40b1577302e006fbd"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:ga5b65e9a9794300c40b1577302e006fbd"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1volatile__mem__functor2.html">volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga5b65e9a9794300c40b1577302e006fbd">retype</a> (const <a class="el" href="classsigc_1_1volatile__mem__functor2.html">volatile_mem_functor2</a>< T_return, T_obj, T_arg1, T_arg2 > & _A_functor)</td></tr>
+<tr class="memdesc:ga5b65e9a9794300c40b1577302e006fbd"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga5b65e9a9794300c40b1577302e006fbd">More...</a><br /></td></tr>
+<tr class="separator:ga5b65e9a9794300c40b1577302e006fbd"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga55236721b80a72f40453d1b939316635"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:ga55236721b80a72f40453d1b939316635"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1volatile__mem__functor3.html">volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga55236721b80a72f40453d1b939316635">retype</a> (const <a class="el" href="classsigc_1_1volatile__mem__functor3.html">volatile_mem_functor3</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3 > & _A_functor)</td></tr>
+<tr class="memdesc:ga55236721b80a72f40453d1b939316635"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga55236721b80a72f40453d1b939316635">More...</a><br /></td></tr>
+<tr class="separator:ga55236721b80a72f40453d1b939316635"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga05d2c3c043bed420ba8ba6f40f42f692"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:ga05d2c3c043bed420ba8ba6f40f42f692"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1volatile__mem__functor4.html">volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga05d2c3c043bed420ba8ba6f40f42f692">retype</a> (const <a class="el" href="classsigc_1_1volatile__mem__functor4.html">volatile_mem_functor4</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > & _A_functor)</td></tr>
+<tr class="memdesc:ga05d2c3c043bed420ba8ba6f40f42f692"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga05d2c3c043bed420ba8ba6f40f42f692">More...</a><br /></td></tr>
+<tr class="separator:ga05d2c3c043bed420ba8ba6f40f42f692"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga42be2d2fbf03fbaba1ad7d8cbbb8bce4"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:ga42be2d2fbf03fbaba1ad7d8cbbb8bce4"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1volatile__mem__functor5.html">volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga42be2d2fbf03fbaba1ad7d8cbbb8bce4">retype</a> (const <a class="el" href="classsigc_1_1volatile__mem__functor5.html">volatile_mem_functor5</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > & _A_functor)</td></tr>
+<tr class="memdesc:ga42be2d2fbf03fbaba1ad7d8cbbb8bce4"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga42be2d2fbf03fbaba1ad7d8cbbb8bce4">More...</a><br /></td></tr>
+<tr class="separator:ga42be2d2fbf03fbaba1ad7d8cbbb8bce4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga255fac4b456d69d033b327b1d533f054"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:ga255fac4b456d69d033b327b1d533f054"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1volatile__mem__functor6.html">volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga255fac4b456d69d033b327b1d533f054">retype</a> (const <a class="el" href="classsigc_1_1volatile__mem__functor6.html">volatile_mem_functor6</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > & _A_functor)</td></tr>
+<tr class="memdesc:ga255fac4b456d69d033b327b1d533f054"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga255fac4b456d69d033b327b1d533f054">More...</a><br /></td></tr>
+<tr class="separator:ga255fac4b456d69d033b327b1d533f054"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga37a057f88e6ffbb8d4172d6446116796"><td class="memTemplParams" colspan="2">template<class T_return , class T_obj , class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:ga37a057f88e6ffbb8d4172d6446116796"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< <a class="el" href="classsigc_1_1volatile__mem__functor7.html">volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga37a057f88e6ffbb8d4172d6446116796">retype</a> (const <a class="el" href="classsigc_1_1volatile__mem__functor7.html">volatile_mem_functor7</a>< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > & _A_functor)</td></tr>
+<tr class="memdesc:ga37a057f88e6ffbb8d4172d6446116796"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">sigc::retype_functor</a> which performs C-style casts on the parameters passed on to the functor. <a href="group__retype.html#ga37a057f88e6ffbb8d4172d6446116796">More...</a><br /></td></tr>
+<tr class="separator:ga37a057f88e6ffbb8d4172d6446116796"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga23a8cdbc12c57fbef0866b5c51d71588"><td class="memTemplParams" colspan="2">template<class T_return , class T_functor > </td></tr>
+<tr class="memitem:ga23a8cdbc12c57fbef0866b5c51d71588"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1retype__return__functor.html">retype_return_functor</a>< T_return, T_functor > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__retype.html#ga23a8cdbc12c57fbef0866b5c51d71588">retype_return</a> (const T_functor & _A_functor)</td></tr>
+<tr class="memdesc:ga23a8cdbc12c57fbef0866b5c51d71588"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="structsigc_1_1retype__return__functor.html" title="Adaptor that performs a C-style cast on the return value of a functor.">sigc::retype_return_functor</a> which performs a C-style cast on the return value of the passed functor. <a href="group__retype.html#ga23a8cdbc12c57fbef0866b5c51d71588">More...</a><br /></td></tr>
+<tr class="separator:ga23a8cdbc12c57fbef0866b5c51d71588"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga8fd1ab36d123ff83dd4cd8dc58bb28e2"><td class="memTemplParams" colspan="2">template<typename T_functor , typename T_obj1 > </td></tr>
+<tr class="memitem:ga8fd1ab36d123ff83dd4cd8dc58bb28e2"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1track__obj__functor1.html">track_obj_functor1</a>< T_functor, T_obj1 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__track__obj.html#ga8fd1ab36d123ff83dd4cd8dc58bb28e2">track_obj</a> (const T_functor & _A_func, const T_obj1 & _A_obj1)</td></tr>
+<tr class="memdesc:ga8fd1ab36d123ff83dd4cd8dc58bb28e2"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object.">sigc::track_obj_functor1</a> which wraps a functor. <a href="group__track__obj.html#ga8fd1ab36d123ff83dd4cd8dc58bb28e2">More...</a><br /></td></tr>
+<tr class="separator:ga8fd1ab36d123ff83dd4cd8dc58bb28e2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga60842510c2387ec49c43149d94fb1b72"><td class="memTemplParams" colspan="2">template<typename T_functor , typename T_obj1 , typename T_obj2 > </td></tr>
+<tr class="memitem:ga60842510c2387ec49c43149d94fb1b72"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1track__obj__functor2.html">track_obj_functor2</a>< T_functor, T_obj1, T_obj2 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__track__obj.html#ga60842510c2387ec49c43149d94fb1b72">track_obj</a> (const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2)</td></tr>
+<tr class="memdesc:ga60842510c2387ec49c43149d94fb1b72"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="classsigc_1_1track__obj__functor2.html" title="track_obj_functor2 wraps a functor and stores 2 references to trackable objects.">sigc::track_obj_functor2</a> which wraps a functor. <a href="group__track__obj.html#ga60842510c2387ec49c43149d94fb1b72">More...</a><br /></td></tr>
+<tr class="separator:ga60842510c2387ec49c43149d94fb1b72"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga52b11304cb05441237a8dcc651cb724e"><td class="memTemplParams" colspan="2">template<typename T_functor , typename T_obj1 , typename T_obj2 , typename T_obj3 > </td></tr>
+<tr class="memitem:ga52b11304cb05441237a8dcc651cb724e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1track__obj__functor3.html">track_obj_functor3</a>< T_functor, T_obj1, T_obj2, T_obj3 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__track__obj.html#ga52b11304cb05441237a8dcc651cb724e">track_obj</a> (const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2, const T_obj3 & _A_obj3)</td></tr>
+<tr class="memdesc:ga52b11304cb05441237a8dcc651cb724e"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="classsigc_1_1track__obj__functor3.html" title="track_obj_functor3 wraps a functor and stores 3 references to trackable objects.">sigc::track_obj_functor3</a> which wraps a functor. <a href="group__track__obj.html#ga52b11304cb05441237a8dcc651cb724e">More...</a><br /></td></tr>
+<tr class="separator:ga52b11304cb05441237a8dcc651cb724e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gaea44f2388c18ca8508818ff6b7756216"><td class="memTemplParams" colspan="2">template<typename T_functor , typename T_obj1 , typename T_obj2 , typename T_obj3 , typename T_obj4 > </td></tr>
+<tr class="memitem:gaea44f2388c18ca8508818ff6b7756216"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1track__obj__functor4.html">track_obj_functor4</a>< T_functor, T_obj1, T_obj2, T_obj3, T_obj4 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__track__obj.html#gaea44f2388c18ca8508818ff6b7756216">track_obj</a> (const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2, const T_obj3 & _A_obj3, const T_obj4 & _A_obj4)</td></tr>
+<tr class="memdesc:gaea44f2388c18ca8508818ff6b7756216"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="classsigc_1_1track__obj__functor4.html" title="track_obj_functor4 wraps a functor and stores 4 references to trackable objects.">sigc::track_obj_functor4</a> which wraps a functor. <a href="group__track__obj.html#gaea44f2388c18ca8508818ff6b7756216">More...</a><br /></td></tr>
+<tr class="separator:gaea44f2388c18ca8508818ff6b7756216"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga337dc48ba1e394f572d5d914b83f57a0"><td class="memTemplParams" colspan="2">template<typename T_functor , typename T_obj1 , typename T_obj2 , typename T_obj3 , typename T_obj4 , typename T_obj5 > </td></tr>
+<tr class="memitem:ga337dc48ba1e394f572d5d914b83f57a0"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1track__obj__functor5.html">track_obj_functor5</a>< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__track__obj.html#ga337dc48ba1e394f572d5d914b83f57a0">track_obj</a> (const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2, const T_obj3 & _A_obj3, const T_obj4 & _A_obj4, const T_obj5 & _A_obj5)</td></tr>
+<tr class="memdesc:ga337dc48ba1e394f572d5d914b83f57a0"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="classsigc_1_1track__obj__functor5.html" title="track_obj_functor5 wraps a functor and stores 5 references to trackable objects.">sigc::track_obj_functor5</a> which wraps a functor. <a href="group__track__obj.html#ga337dc48ba1e394f572d5d914b83f57a0">More...</a><br /></td></tr>
+<tr class="separator:ga337dc48ba1e394f572d5d914b83f57a0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga0304ca1269ed352fcc1c81324062302e"><td class="memTemplParams" colspan="2">template<typename T_functor , typename T_obj1 , typename T_obj2 , typename T_obj3 , typename T_obj4 , typename T_obj5 , typename T_obj6 > </td></tr>
+<tr class="memitem:ga0304ca1269ed352fcc1c81324062302e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1track__obj__functor6.html">track_obj_functor6</a>< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__track__obj.html#ga0304ca1269ed352fcc1c81324062302e">track_obj</a> (const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2, const T_obj3 & _A_obj3, const T_obj4 & _A_obj4, const T_obj5 & _A_obj5, const T_obj6 & _A_obj6)</td></tr>
+<tr class="memdesc:ga0304ca1269ed352fcc1c81324062302e"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="classsigc_1_1track__obj__functor6.html" title="track_obj_functor6 wraps a functor and stores 6 references to trackable objects.">sigc::track_obj_functor6</a> which wraps a functor. <a href="group__track__obj.html#ga0304ca1269ed352fcc1c81324062302e">More...</a><br /></td></tr>
+<tr class="separator:ga0304ca1269ed352fcc1c81324062302e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga5ea3e9f52643d7ab1bcfa4f419e7d38f"><td class="memTemplParams" colspan="2">template<typename T_functor , typename T_obj1 , typename T_obj2 , typename T_obj3 , typename T_obj4 , typename T_obj5 , typename T_obj6 , typename T_obj7 > </td></tr>
+<tr class="memitem:ga5ea3e9f52643d7ab1bcfa4f419e7d38f"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1track__obj__functor7.html">track_obj_functor7</a>< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6, T_obj7 > </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__track__obj.html#ga5ea3e9f52643d7ab1bcfa4f419e7d38f">track_obj</a> (const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2, const T_obj3 & _A_obj3, const T_obj4 & _A_obj4, const T_obj5 & _A_obj5, const T_obj6 & _A_obj6, const T_obj7 & _A_obj7)</td></tr>
+<tr class="memdesc:ga5ea3e9f52643d7ab1bcfa4f419e7d38f"><td class="mdescLeft"> </td><td class="mdescRight">Creates an adaptor of type <a class="el" href="classsigc_1_1track__obj__functor7.html" title="track_obj_functor7 wraps a functor and stores 7 references to trackable objects.">sigc::track_obj_functor7</a> which wraps a functor. <a href="group__track__obj.html#ga5ea3e9f52643d7ab1bcfa4f419e7d38f">More...</a><br /></td></tr>
+<tr class="separator:ga5ea3e9f52643d7ab1bcfa4f419e7d38f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2f758c77e8743093f938d0c5dbf06778"><td class="memTemplParams" colspan="2">template<class T_type > </td></tr>
+<tr class="memitem:a2f758c77e8743093f938d0c5dbf06778"><td class="memTemplItemLeft" align="right" valign="top">const T_type & </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#a2f758c77e8743093f938d0c5dbf06778">unwrap</a> (const <a class="el" href="structsigc_1_1const__reference__wrapper.html">const_reference_wrapper</a>< T_type > & v)</td></tr>
+<tr class="separator:a2f758c77e8743093f938d0c5dbf06778"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3b5529822bdaf60f07456633e0f40282"><td class="memTemplParams" colspan="2">template<class T_type > </td></tr>
+<tr class="memitem:a3b5529822bdaf60f07456633e0f40282"><td class="memTemplItemLeft" align="right" valign="top">T_type & </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#a3b5529822bdaf60f07456633e0f40282">unwrap</a> (const <a class="el" href="structsigc_1_1reference__wrapper.html">reference_wrapper</a>< T_type > & v)</td></tr>
+<tr class="separator:a3b5529822bdaf60f07456633e0f40282"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3256789f3d3bb134471d7cf8fcf4d91a"><td class="memTemplParams" colspan="2">template<class T_type > </td></tr>
+<tr class="memitem:a3256789f3d3bb134471d7cf8fcf4d91a"><td class="memTemplItemLeft" align="right" valign="top">T_type & </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="namespacesigc.html#a3256789f3d3bb134471d7cf8fcf4d91a">unwrap</a> (const <a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a03225.html">std::reference_wrapper</a>< T_type > & v)</td></tr>
+<tr class="separator:a3256789f3d3bb134471d7cf8fcf4d91a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ga64cb7832acc1e58efb5ffe0b4f5e9404"><td class="memTemplParams" colspan="2">template<class T_action , class T_functor > </td></tr>
+<tr class="memitem:ga64cb7832acc1e58efb5ffe0b4f5e9404"><td class="memTemplItemLeft" align="right" valign="top">void </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404">visit_each</a> (const T_action & _A_action, const T_functor & _A_functor)</td></tr>
+<tr class="memdesc:ga64cb7832acc1e58efb5ffe0b4f5e9404"><td class="mdescLeft"> </td><td class="mdescRight">This function performs a functor on each of the targets of a functor. <a href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404">More...</a><br /></td></tr>
+<tr class="separator:ga64cb7832acc1e58efb5ffe0b4f5e9404"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:gada222d975b87d64cfa7a7f29244ae587"><td class="memTemplParams" colspan="2">template<class T_type , class T_action , class T_functor > </td></tr>
+<tr class="memitem:gada222d975b87d64cfa7a7f29244ae587"><td class="memTemplItemLeft" align="right" valign="top">void </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="group__sigcfunctors.html#gada222d975b87d64cfa7a7f29244ae587">visit_each_type</a> (const T_action & _A_action, const T_functor & _A_functor)</td></tr>
+<tr class="memdesc:gada222d975b87d64cfa7a7f29244ae587"><td class="mdescLeft"> </td><td class="mdescRight">This function performs a functor on each of the targets of a functor limited to a restricted type. <a href="group__sigcfunctors.html#gada222d975b87d64cfa7a7f29244ae587">More...</a><br /></td></tr>
+<tr class="separator:gada222d975b87d64cfa7a7f29244ae587"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><p>The libsigc++ namespace. </p>
+</div><h2 class="groupheader">Typedef Documentation</h2>
+<a id="ab7791439fb79592300826fe076a8e3d1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab7791439fb79592300826fe076a8e3d1">◆ </a></span>deduce_result_t</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_functor , typename... T_args> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">using <a class="el" href="namespacesigc.html#ab7791439fb79592300826fe076a8e3d1">sigc::deduce_result_t</a> = typedef typename <a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_functor, T_args...>::type</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aa2d13c7fc829cfec6e0f9d5092f2aa79"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa2d13c7fc829cfec6e0f9d5092f2aa79">◆ </a></span>type_trait_pass_t</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">using <a class="el" href="namespacesigc.html#aa2d13c7fc829cfec6e0f9d5092f2aa79">sigc::type_trait_pass_t</a> = typedef typename <a class="el" href="structsigc_1_1type__trait.html">type_trait</a><T>::pass</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aa0d56c61023af35c47b79db80b32fd2e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa0d56c61023af35c47b79db80b32fd2e">◆ </a></span>type_trait_take_t</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">using <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">sigc::type_trait_take_t</a> = typedef typename <a class="el" href="structsigc_1_1type__trait.html">type_trait</a><T>::take</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Function Documentation</h2>
+<a id="a0ae3b8a1ba26920cee4d7d9df2c39ed9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0ae3b8a1ba26920cee4d7d9df2c39ed9">◆ </a></span>exception_catch()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_catcher > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1exception__catch__functor.html">exception_catch_functor</a><T_functor, T_catcher> sigc::exception_catch </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_catcher & </td>
+ <td class="paramname"><em>_A_catcher</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="gaeef6e55681664df29b31edec51ea034d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaeef6e55681664df29b31edec51ea034d">◆ </a></span>mem_fun() <span class="overload">[1/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">bound_const_volatile_mem_functor0</a><T_return, T_obj> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)() const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html" title="bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object...">sigc::bound_const_volatile_mem_functor0</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaeef6e55681664df29b31edec51ea034d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaeef6e55681664df29b31edec51ea034d">◆ </a></span>mem_fun() <span class="overload">[2/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html">bound_const_mem_functor0</a><T_return, T_obj> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)() const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor0.html" title="bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance.">sigc::bound_const_mem_functor0</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaeef6e55681664df29b31edec51ea034d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaeef6e55681664df29b31edec51ea034d">◆ </a></span>mem_fun() <span class="overload">[3/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">bound_volatile_mem_functor0</a><T_return, T_obj> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)() volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html" title="bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance.">sigc::bound_volatile_mem_functor0</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga7de39a04dfc6d37b2d12a25cdccfbe95"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga7de39a04dfc6d37b2d12a25cdccfbe95">◆ </a></span>mem_fun() <span class="overload">[4/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">bound_const_volatile_mem_functor1</a><T_return, T_obj, T_arg1> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1) const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html" title="bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object...">sigc::bound_const_volatile_mem_functor1</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga7de39a04dfc6d37b2d12a25cdccfbe95"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga7de39a04dfc6d37b2d12a25cdccfbe95">◆ </a></span>mem_fun() <span class="overload">[5/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html">bound_const_mem_functor1</a><T_return, T_obj, T_arg1> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1) const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor1.html" title="bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance.">sigc::bound_const_mem_functor1</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga7de39a04dfc6d37b2d12a25cdccfbe95"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga7de39a04dfc6d37b2d12a25cdccfbe95">◆ </a></span>mem_fun() <span class="overload">[6/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">bound_volatile_mem_functor1</a><T_return, T_obj, T_arg1> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1) volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html" title="bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance.">sigc::bound_volatile_mem_functor1</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gab1add5c927b51b935b4f2d40558079fa"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gab1add5c927b51b935b4f2d40558079fa">◆ </a></span>mem_fun() <span class="overload">[7/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">bound_const_volatile_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2) const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html" title="bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object...">sigc::bound_const_volatile_mem_functor2</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gab1add5c927b51b935b4f2d40558079fa"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gab1add5c927b51b935b4f2d40558079fa">◆ </a></span>mem_fun() <span class="overload">[8/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html">bound_const_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2) const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor2.html" title="bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance.">sigc::bound_const_mem_functor2</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gab1add5c927b51b935b4f2d40558079fa"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gab1add5c927b51b935b4f2d40558079fa">◆ </a></span>mem_fun() <span class="overload">[9/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">bound_volatile_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2) volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html" title="bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance.">sigc::bound_volatile_mem_functor2</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga1f1aa3b60c0d2d8b2470bba0b2b36023"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga1f1aa3b60c0d2d8b2470bba0b2b36023">◆ </a></span>mem_fun() <span class="overload">[10/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">bound_const_volatile_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3) const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html" title="bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object...">sigc::bound_const_volatile_mem_functor3</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga1f1aa3b60c0d2d8b2470bba0b2b36023"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga1f1aa3b60c0d2d8b2470bba0b2b36023">◆ </a></span>mem_fun() <span class="overload">[11/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html">bound_const_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3) const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor3.html" title="bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance.">sigc::bound_const_mem_functor3</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga1f1aa3b60c0d2d8b2470bba0b2b36023"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga1f1aa3b60c0d2d8b2470bba0b2b36023">◆ </a></span>mem_fun() <span class="overload">[12/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">bound_volatile_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3) volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html" title="bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance.">sigc::bound_volatile_mem_functor3</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga481ef34d8423d26e8ff0a1916cd295d5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga481ef34d8423d26e8ff0a1916cd295d5">◆ </a></span>mem_fun() <span class="overload">[13/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">bound_const_volatile_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html" title="bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object...">sigc::bound_const_volatile_mem_functor4</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga481ef34d8423d26e8ff0a1916cd295d5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga481ef34d8423d26e8ff0a1916cd295d5">◆ </a></span>mem_fun() <span class="overload">[14/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html">bound_const_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4) const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor4.html" title="bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance.">sigc::bound_const_mem_functor4</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga481ef34d8423d26e8ff0a1916cd295d5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga481ef34d8423d26e8ff0a1916cd295d5">◆ </a></span>mem_fun() <span class="overload">[15/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">bound_volatile_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4) volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html" title="bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance.">sigc::bound_volatile_mem_functor4</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga09fb13b1684ec7c092ffef695dbb261a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga09fb13b1684ec7c092ffef695dbb261a">◆ </a></span>mem_fun() <span class="overload">[16/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">bound_const_volatile_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html" title="bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object...">sigc::bound_const_volatile_mem_functor5</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga09fb13b1684ec7c092ffef695dbb261a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga09fb13b1684ec7c092ffef695dbb261a">◆ </a></span>mem_fun() <span class="overload">[17/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html">bound_const_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor5.html" title="bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance.">sigc::bound_const_mem_functor5</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga09fb13b1684ec7c092ffef695dbb261a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga09fb13b1684ec7c092ffef695dbb261a">◆ </a></span>mem_fun() <span class="overload">[18/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">bound_volatile_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html" title="bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance.">sigc::bound_volatile_mem_functor5</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga0d9b992d69123a524b6c70c458ad0d40"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga0d9b992d69123a524b6c70c458ad0d40">◆ </a></span>mem_fun() <span class="overload">[19/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">bound_const_volatile_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html" title="bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object...">sigc::bound_const_volatile_mem_functor6</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga0d9b992d69123a524b6c70c458ad0d40"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga0d9b992d69123a524b6c70c458ad0d40">◆ </a></span>mem_fun() <span class="overload">[20/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html">bound_const_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor6.html" title="bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance.">sigc::bound_const_mem_functor6</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga0d9b992d69123a524b6c70c458ad0d40"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga0d9b992d69123a524b6c70c458ad0d40">◆ </a></span>mem_fun() <span class="overload">[21/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">bound_volatile_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html" title="bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance.">sigc::bound_volatile_mem_functor6</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga5dcdaf235baa50049e6088d246853037"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga5dcdaf235baa50049e6088d246853037">◆ </a></span>mem_fun() <span class="overload">[22/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">bound_const_volatile_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html" title="bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object...">sigc::bound_const_volatile_mem_functor7</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga5dcdaf235baa50049e6088d246853037"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga5dcdaf235baa50049e6088d246853037">◆ </a></span>mem_fun() <span class="overload">[23/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html">bound_const_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor7.html" title="bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance.">sigc::bound_const_mem_functor7</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga5dcdaf235baa50049e6088d246853037"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga5dcdaf235baa50049e6088d246853037">◆ </a></span>mem_fun() <span class="overload">[24/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">bound_volatile_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html" title="bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance.">sigc::bound_volatile_mem_functor7</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga7f57ec0156d33b4aa98e259d2e2062db"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga7f57ec0156d33b4aa98e259d2e2062db">◆ </a></span>mem_fun() <span class="overload">[25/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">bound_const_volatile_mem_functor0</a><T_return, T_obj> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)() const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html" title="bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object...">sigc::bound_const_volatile_mem_functor0</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000122">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga7f57ec0156d33b4aa98e259d2e2062db"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga7f57ec0156d33b4aa98e259d2e2062db">◆ </a></span>mem_fun() <span class="overload">[26/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html">bound_const_mem_functor0</a><T_return, T_obj> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)() const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor0.html" title="bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance.">sigc::bound_const_mem_functor0</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000106">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga7f57ec0156d33b4aa98e259d2e2062db"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga7f57ec0156d33b4aa98e259d2e2062db">◆ </a></span>mem_fun() <span class="overload">[27/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">bound_volatile_mem_functor0</a><T_return, T_obj> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)() volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html" title="bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance.">sigc::bound_volatile_mem_functor0</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000114">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga0df7af9f32990cc624c4bb60782b4f78"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga0df7af9f32990cc624c4bb60782b4f78">◆ </a></span>mem_fun() <span class="overload">[28/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">bound_const_volatile_mem_functor1</a><T_return, T_obj, T_arg1> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1) const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html" title="bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object...">sigc::bound_const_volatile_mem_functor1</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000123">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga0df7af9f32990cc624c4bb60782b4f78"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga0df7af9f32990cc624c4bb60782b4f78">◆ </a></span>mem_fun() <span class="overload">[29/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html">bound_const_mem_functor1</a><T_return, T_obj, T_arg1> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1) const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor1.html" title="bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance.">sigc::bound_const_mem_functor1</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000107">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga0df7af9f32990cc624c4bb60782b4f78"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga0df7af9f32990cc624c4bb60782b4f78">◆ </a></span>mem_fun() <span class="overload">[30/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">bound_volatile_mem_functor1</a><T_return, T_obj, T_arg1> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1) volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html" title="bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance.">sigc::bound_volatile_mem_functor1</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000115">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga118b2610268701be95cdc6fddb7bab3b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga118b2610268701be95cdc6fddb7bab3b">◆ </a></span>mem_fun() <span class="overload">[31/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">bound_const_volatile_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2) const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html" title="bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object...">sigc::bound_const_volatile_mem_functor2</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000124">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga118b2610268701be95cdc6fddb7bab3b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga118b2610268701be95cdc6fddb7bab3b">◆ </a></span>mem_fun() <span class="overload">[32/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html">bound_const_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2) const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor2.html" title="bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance.">sigc::bound_const_mem_functor2</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000108">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga118b2610268701be95cdc6fddb7bab3b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga118b2610268701be95cdc6fddb7bab3b">◆ </a></span>mem_fun() <span class="overload">[33/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">bound_volatile_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2) volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html" title="bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance.">sigc::bound_volatile_mem_functor2</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000116">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaeb6bd4518e0f0c524dba13a6cbb2e319"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaeb6bd4518e0f0c524dba13a6cbb2e319">◆ </a></span>mem_fun() <span class="overload">[34/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">bound_const_volatile_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3) const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html" title="bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object...">sigc::bound_const_volatile_mem_functor3</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000125">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaeb6bd4518e0f0c524dba13a6cbb2e319"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaeb6bd4518e0f0c524dba13a6cbb2e319">◆ </a></span>mem_fun() <span class="overload">[35/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html">bound_const_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3) const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor3.html" title="bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance.">sigc::bound_const_mem_functor3</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000109">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaeb6bd4518e0f0c524dba13a6cbb2e319"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaeb6bd4518e0f0c524dba13a6cbb2e319">◆ </a></span>mem_fun() <span class="overload">[36/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">bound_volatile_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3) volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html" title="bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance.">sigc::bound_volatile_mem_functor3</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000117">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga02c906c95895c58e39ee301bb1577994"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga02c906c95895c58e39ee301bb1577994">◆ </a></span>mem_fun() <span class="overload">[37/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">bound_const_volatile_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html" title="bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object...">sigc::bound_const_volatile_mem_functor4</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000126">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga02c906c95895c58e39ee301bb1577994"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga02c906c95895c58e39ee301bb1577994">◆ </a></span>mem_fun() <span class="overload">[38/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html">bound_const_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4) const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor4.html" title="bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance.">sigc::bound_const_mem_functor4</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000110">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga02c906c95895c58e39ee301bb1577994"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga02c906c95895c58e39ee301bb1577994">◆ </a></span>mem_fun() <span class="overload">[39/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">bound_volatile_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4) volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html" title="bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance.">sigc::bound_volatile_mem_functor4</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000118">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gab138ae1a340be983166b69872826b37d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gab138ae1a340be983166b69872826b37d">◆ </a></span>mem_fun() <span class="overload">[40/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">bound_const_volatile_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html" title="bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object...">sigc::bound_const_volatile_mem_functor5</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000127">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gab138ae1a340be983166b69872826b37d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gab138ae1a340be983166b69872826b37d">◆ </a></span>mem_fun() <span class="overload">[41/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html">bound_const_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor5.html" title="bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance.">sigc::bound_const_mem_functor5</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000111">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gab138ae1a340be983166b69872826b37d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gab138ae1a340be983166b69872826b37d">◆ </a></span>mem_fun() <span class="overload">[42/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">bound_volatile_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html" title="bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance.">sigc::bound_volatile_mem_functor5</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000119">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga3e3841c4844715d2f2d832ed506f028f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga3e3841c4844715d2f2d832ed506f028f">◆ </a></span>mem_fun() <span class="overload">[43/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">bound_const_volatile_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html" title="bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object...">sigc::bound_const_volatile_mem_functor6</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000128">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga3e3841c4844715d2f2d832ed506f028f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga3e3841c4844715d2f2d832ed506f028f">◆ </a></span>mem_fun() <span class="overload">[44/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html">bound_const_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor6.html" title="bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance.">sigc::bound_const_mem_functor6</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000112">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga3e3841c4844715d2f2d832ed506f028f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga3e3841c4844715d2f2d832ed506f028f">◆ </a></span>mem_fun() <span class="overload">[45/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">bound_volatile_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html" title="bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance.">sigc::bound_volatile_mem_functor6</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000120">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaea5a2ace2699b8d1ffe93585e335548d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaea5a2ace2699b8d1ffe93585e335548d">◆ </a></span>mem_fun() <span class="overload">[46/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">bound_const_volatile_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html" title="bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object...">sigc::bound_const_volatile_mem_functor7</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000129">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaea5a2ace2699b8d1ffe93585e335548d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaea5a2ace2699b8d1ffe93585e335548d">◆ </a></span>mem_fun() <span class="overload">[47/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html">bound_const_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor7.html" title="bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance.">sigc::bound_const_mem_functor7</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000113">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaea5a2ace2699b8d1ffe93585e335548d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaea5a2ace2699b8d1ffe93585e335548d">◆ </a></span>mem_fun() <span class="overload">[48/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">bound_volatile_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html" title="bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance.">sigc::bound_volatile_mem_functor7</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000121">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gadf6b6d22c503b439019f0a2e77352419"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gadf6b6d22c503b439019f0a2e77352419">◆ </a></span>mem_fun() <span class="overload">[49/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">const_volatile_mem_functor0</a><T_return, T_obj> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)() const volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html" title="const_volatile_mem_functor0 wraps const volatile methods with 0 argument(s).">sigc::const_volatile_mem_functor0</a> which wraps a const volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gadf6b6d22c503b439019f0a2e77352419"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gadf6b6d22c503b439019f0a2e77352419">◆ </a></span>mem_fun() <span class="overload">[50/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor0.html">const_mem_functor0</a><T_return, T_obj> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)() const </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor0.html" title="const_mem_functor0 wraps const methods with 0 argument(s).">sigc::const_mem_functor0</a> which wraps a const method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gadf6b6d22c503b439019f0a2e77352419"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gadf6b6d22c503b439019f0a2e77352419">◆ </a></span>mem_fun() <span class="overload">[51/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor0.html">volatile_mem_functor0</a><T_return, T_obj> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)() volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor0.html" title="volatile_mem_functor0 wraps volatile methods with 0 argument(s).">sigc::volatile_mem_functor0</a> which wraps a volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gab661fef0f04e2e439912eee6989e9657"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gab661fef0f04e2e439912eee6989e9657">◆ </a></span>mem_fun() <span class="overload">[52/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">const_volatile_mem_functor1</a><T_return, T_obj, T_arg1> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1) const volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html" title="const_volatile_mem_functor1 wraps const volatile methods with 1 argument(s).">sigc::const_volatile_mem_functor1</a> which wraps a const volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gab661fef0f04e2e439912eee6989e9657"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gab661fef0f04e2e439912eee6989e9657">◆ </a></span>mem_fun() <span class="overload">[53/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor1.html">const_mem_functor1</a><T_return, T_obj, T_arg1> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1) const </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor1.html" title="const_mem_functor1 wraps const methods with 1 argument(s).">sigc::const_mem_functor1</a> which wraps a const method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gab661fef0f04e2e439912eee6989e9657"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gab661fef0f04e2e439912eee6989e9657">◆ </a></span>mem_fun() <span class="overload">[54/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor1.html">volatile_mem_functor1</a><T_return, T_obj, T_arg1> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1) volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor1.html" title="volatile_mem_functor1 wraps volatile methods with 1 argument(s).">sigc::volatile_mem_functor1</a> which wraps a volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5">◆ </a></span>mem_fun() <span class="overload">[55/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">const_volatile_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2) const volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html" title="const_volatile_mem_functor2 wraps const volatile methods with 2 argument(s).">sigc::const_volatile_mem_functor2</a> which wraps a const volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5">◆ </a></span>mem_fun() <span class="overload">[56/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor2.html">const_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2) const </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor2.html" title="const_mem_functor2 wraps const methods with 2 argument(s).">sigc::const_mem_functor2</a> which wraps a const method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5">◆ </a></span>mem_fun() <span class="overload">[57/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor2.html">volatile_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2) volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor2.html" title="volatile_mem_functor2 wraps volatile methods with 2 argument(s).">sigc::volatile_mem_functor2</a> which wraps a volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaa3778234963fa65d4f638856d91109d1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaa3778234963fa65d4f638856d91109d1">◆ </a></span>mem_fun() <span class="overload">[58/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">const_volatile_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3) const volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html" title="const_volatile_mem_functor3 wraps const volatile methods with 3 argument(s).">sigc::const_volatile_mem_functor3</a> which wraps a const volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaa3778234963fa65d4f638856d91109d1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaa3778234963fa65d4f638856d91109d1">◆ </a></span>mem_fun() <span class="overload">[59/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor3.html">const_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3) const </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor3.html" title="const_mem_functor3 wraps const methods with 3 argument(s).">sigc::const_mem_functor3</a> which wraps a const method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaa3778234963fa65d4f638856d91109d1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaa3778234963fa65d4f638856d91109d1">◆ </a></span>mem_fun() <span class="overload">[60/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor3.html">volatile_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3) volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor3.html" title="volatile_mem_functor3 wraps volatile methods with 3 argument(s).">sigc::volatile_mem_functor3</a> which wraps a volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gadadd40aba6dadd0edbaac609dfae3938"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gadadd40aba6dadd0edbaac609dfae3938">◆ </a></span>mem_fun() <span class="overload">[61/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">const_volatile_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html" title="const_volatile_mem_functor4 wraps const volatile methods with 4 argument(s).">sigc::const_volatile_mem_functor4</a> which wraps a const volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gadadd40aba6dadd0edbaac609dfae3938"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gadadd40aba6dadd0edbaac609dfae3938">◆ </a></span>mem_fun() <span class="overload">[62/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor4.html">const_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4) const </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor4.html" title="const_mem_functor4 wraps const methods with 4 argument(s).">sigc::const_mem_functor4</a> which wraps a const method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gadadd40aba6dadd0edbaac609dfae3938"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gadadd40aba6dadd0edbaac609dfae3938">◆ </a></span>mem_fun() <span class="overload">[63/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor4.html">volatile_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4) volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor4.html" title="volatile_mem_functor4 wraps volatile methods with 4 argument(s).">sigc::volatile_mem_functor4</a> which wraps a volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaa01df6c622d59cfd2d0d8aa3c04c36d1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaa01df6c622d59cfd2d0d8aa3c04c36d1">◆ </a></span>mem_fun() <span class="overload">[64/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">const_volatile_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html" title="const_volatile_mem_functor5 wraps const volatile methods with 5 argument(s).">sigc::const_volatile_mem_functor5</a> which wraps a const volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaa01df6c622d59cfd2d0d8aa3c04c36d1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaa01df6c622d59cfd2d0d8aa3c04c36d1">◆ </a></span>mem_fun() <span class="overload">[65/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor5.html">const_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor5.html" title="const_mem_functor5 wraps const methods with 5 argument(s).">sigc::const_mem_functor5</a> which wraps a const method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaa01df6c622d59cfd2d0d8aa3c04c36d1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaa01df6c622d59cfd2d0d8aa3c04c36d1">◆ </a></span>mem_fun() <span class="overload">[66/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor5.html">volatile_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor5.html" title="volatile_mem_functor5 wraps volatile methods with 5 argument(s).">sigc::volatile_mem_functor5</a> which wraps a volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga9030b647c35e06c68342fee34e8fd320"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga9030b647c35e06c68342fee34e8fd320">◆ </a></span>mem_fun() <span class="overload">[67/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">const_volatile_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html" title="const_volatile_mem_functor6 wraps const volatile methods with 6 argument(s).">sigc::const_volatile_mem_functor6</a> which wraps a const volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga9030b647c35e06c68342fee34e8fd320"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga9030b647c35e06c68342fee34e8fd320">◆ </a></span>mem_fun() <span class="overload">[68/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor6.html">const_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor6.html" title="const_mem_functor6 wraps const methods with 6 argument(s).">sigc::const_mem_functor6</a> which wraps a const method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga9030b647c35e06c68342fee34e8fd320"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga9030b647c35e06c68342fee34e8fd320">◆ </a></span>mem_fun() <span class="overload">[69/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor6.html">volatile_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor6.html" title="volatile_mem_functor6 wraps volatile methods with 6 argument(s).">sigc::volatile_mem_functor6</a> which wraps a volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga54e4bf947e8c93c56931b8e8f7ed0d2e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga54e4bf947e8c93c56931b8e8f7ed0d2e">◆ </a></span>mem_fun() <span class="overload">[70/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">const_volatile_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html" title="const_volatile_mem_functor7 wraps const volatile methods with 7 argument(s).">sigc::const_volatile_mem_functor7</a> which wraps a const volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga54e4bf947e8c93c56931b8e8f7ed0d2e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga54e4bf947e8c93c56931b8e8f7ed0d2e">◆ </a></span>mem_fun() <span class="overload">[71/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor7.html">const_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor7.html" title="const_mem_functor7 wraps const methods with 7 argument(s).">sigc::const_mem_functor7</a> which wraps a const method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga54e4bf947e8c93c56931b8e8f7ed0d2e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga54e4bf947e8c93c56931b8e8f7ed0d2e">◆ </a></span>mem_fun() <span class="overload">[72/72]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor7.html">volatile_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sigc::mem_fun </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor7.html" title="volatile_mem_functor7 wraps volatile methods with 7 argument(s).">sigc::volatile_mem_functor7</a> which wraps a volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaf71277763f14050e2d270fcf3ea41dc9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaf71277763f14050e2d270fcf3ea41dc9">◆ </a></span>mem_fun0() <span class="overload">[1/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">bound_const_volatile_mem_functor0</a><T_return, T_obj> sigc::mem_fun0 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)() const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html" title="bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object...">sigc::bound_const_volatile_mem_functor0</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaf71277763f14050e2d270fcf3ea41dc9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaf71277763f14050e2d270fcf3ea41dc9">◆ </a></span>mem_fun0() <span class="overload">[2/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html">bound_const_mem_functor0</a><T_return, T_obj> sigc::mem_fun0 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)() const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor0.html" title="bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance.">sigc::bound_const_mem_functor0</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaf71277763f14050e2d270fcf3ea41dc9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaf71277763f14050e2d270fcf3ea41dc9">◆ </a></span>mem_fun0() <span class="overload">[3/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">bound_volatile_mem_functor0</a><T_return, T_obj> sigc::mem_fun0 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)() volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html" title="bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance.">sigc::bound_volatile_mem_functor0</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gae03d0b73b85e85d2ad8bc43b19b855e3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gae03d0b73b85e85d2ad8bc43b19b855e3">◆ </a></span>mem_fun0() <span class="overload">[4/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html">bound_const_volatile_mem_functor0</a><T_return, T_obj> sigc::mem_fun0 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)() const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor0.html" title="bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object...">sigc::bound_const_volatile_mem_functor0</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000090">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gae03d0b73b85e85d2ad8bc43b19b855e3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gae03d0b73b85e85d2ad8bc43b19b855e3">◆ </a></span>mem_fun0() <span class="overload">[5/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor0.html">bound_const_mem_functor0</a><T_return, T_obj> sigc::mem_fun0 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)() const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor0.html" title="bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance.">sigc::bound_const_mem_functor0</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000074">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gae03d0b73b85e85d2ad8bc43b19b855e3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gae03d0b73b85e85d2ad8bc43b19b855e3">◆ </a></span>mem_fun0() <span class="overload">[6/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html">bound_volatile_mem_functor0</a><T_return, T_obj> sigc::mem_fun0 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)() volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor0.html" title="bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance.">sigc::bound_volatile_mem_functor0</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000082">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga765b35689a909fbc2a627be8256c5b1f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga765b35689a909fbc2a627be8256c5b1f">◆ </a></span>mem_fun0() <span class="overload">[7/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor0.html">const_volatile_mem_functor0</a><T_return, T_obj> sigc::mem_fun0 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)() const volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor0.html" title="const_volatile_mem_functor0 wraps const volatile methods with 0 argument(s).">sigc::const_volatile_mem_functor0</a> which wraps a const volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga765b35689a909fbc2a627be8256c5b1f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga765b35689a909fbc2a627be8256c5b1f">◆ </a></span>mem_fun0() <span class="overload">[8/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor0.html">const_mem_functor0</a><T_return, T_obj> sigc::mem_fun0 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)() const </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor0.html" title="const_mem_functor0 wraps const methods with 0 argument(s).">sigc::const_mem_functor0</a> which wraps a const method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga765b35689a909fbc2a627be8256c5b1f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga765b35689a909fbc2a627be8256c5b1f">◆ </a></span>mem_fun0() <span class="overload">[9/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor0.html">volatile_mem_functor0</a><T_return, T_obj> sigc::mem_fun0 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)() volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor0.html" title="volatile_mem_functor0 wraps volatile methods with 0 argument(s).">sigc::volatile_mem_functor0</a> which wraps a volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaade596a4dacfd1429039525bb9f399d0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaade596a4dacfd1429039525bb9f399d0">◆ </a></span>mem_fun1() <span class="overload">[1/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">bound_const_volatile_mem_functor1</a><T_return, T_obj, T_arg1> sigc::mem_fun1 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1) const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html" title="bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object...">sigc::bound_const_volatile_mem_functor1</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaade596a4dacfd1429039525bb9f399d0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaade596a4dacfd1429039525bb9f399d0">◆ </a></span>mem_fun1() <span class="overload">[2/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html">bound_const_mem_functor1</a><T_return, T_obj, T_arg1> sigc::mem_fun1 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1) const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor1.html" title="bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance.">sigc::bound_const_mem_functor1</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaade596a4dacfd1429039525bb9f399d0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaade596a4dacfd1429039525bb9f399d0">◆ </a></span>mem_fun1() <span class="overload">[3/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">bound_volatile_mem_functor1</a><T_return, T_obj, T_arg1> sigc::mem_fun1 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1) volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html" title="bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance.">sigc::bound_volatile_mem_functor1</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga3dd8d2ed97310dbf4fa394999f0be7b7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga3dd8d2ed97310dbf4fa394999f0be7b7">◆ </a></span>mem_fun1() <span class="overload">[4/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html">bound_const_volatile_mem_functor1</a><T_return, T_obj, T_arg1> sigc::mem_fun1 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1) const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor1.html" title="bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object...">sigc::bound_const_volatile_mem_functor1</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000091">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga3dd8d2ed97310dbf4fa394999f0be7b7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga3dd8d2ed97310dbf4fa394999f0be7b7">◆ </a></span>mem_fun1() <span class="overload">[5/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor1.html">bound_const_mem_functor1</a><T_return, T_obj, T_arg1> sigc::mem_fun1 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1) const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor1.html" title="bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance.">sigc::bound_const_mem_functor1</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000075">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga3dd8d2ed97310dbf4fa394999f0be7b7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga3dd8d2ed97310dbf4fa394999f0be7b7">◆ </a></span>mem_fun1() <span class="overload">[6/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html">bound_volatile_mem_functor1</a><T_return, T_obj, T_arg1> sigc::mem_fun1 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1) volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor1.html" title="bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance.">sigc::bound_volatile_mem_functor1</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000083">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gae0bebf0d8a2d36d93746c23d9eea668d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gae0bebf0d8a2d36d93746c23d9eea668d">◆ </a></span>mem_fun1() <span class="overload">[7/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor1.html">const_volatile_mem_functor1</a><T_return, T_obj, T_arg1> sigc::mem_fun1 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1) const volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor1.html" title="const_volatile_mem_functor1 wraps const volatile methods with 1 argument(s).">sigc::const_volatile_mem_functor1</a> which wraps a const volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gae0bebf0d8a2d36d93746c23d9eea668d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gae0bebf0d8a2d36d93746c23d9eea668d">◆ </a></span>mem_fun1() <span class="overload">[8/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor1.html">const_mem_functor1</a><T_return, T_obj, T_arg1> sigc::mem_fun1 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1) const </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor1.html" title="const_mem_functor1 wraps const methods with 1 argument(s).">sigc::const_mem_functor1</a> which wraps a const method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gae0bebf0d8a2d36d93746c23d9eea668d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gae0bebf0d8a2d36d93746c23d9eea668d">◆ </a></span>mem_fun1() <span class="overload">[9/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor1.html">volatile_mem_functor1</a><T_return, T_obj, T_arg1> sigc::mem_fun1 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1) volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor1.html" title="volatile_mem_functor1 wraps volatile methods with 1 argument(s).">sigc::volatile_mem_functor1</a> which wraps a volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaee7652f1a0625df50af50e28b5e2423e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaee7652f1a0625df50af50e28b5e2423e">◆ </a></span>mem_fun2() <span class="overload">[1/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">bound_const_volatile_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2> sigc::mem_fun2 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2) const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html" title="bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object...">sigc::bound_const_volatile_mem_functor2</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaee7652f1a0625df50af50e28b5e2423e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaee7652f1a0625df50af50e28b5e2423e">◆ </a></span>mem_fun2() <span class="overload">[2/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html">bound_const_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2> sigc::mem_fun2 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2) const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor2.html" title="bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance.">sigc::bound_const_mem_functor2</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaee7652f1a0625df50af50e28b5e2423e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaee7652f1a0625df50af50e28b5e2423e">◆ </a></span>mem_fun2() <span class="overload">[3/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">bound_volatile_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2> sigc::mem_fun2 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2) volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html" title="bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance.">sigc::bound_volatile_mem_functor2</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga184da4166c8b5409dc4b98d7bc16dff8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga184da4166c8b5409dc4b98d7bc16dff8">◆ </a></span>mem_fun2() <span class="overload">[4/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html">bound_const_volatile_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2> sigc::mem_fun2 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2) const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor2.html" title="bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object...">sigc::bound_const_volatile_mem_functor2</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000092">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga184da4166c8b5409dc4b98d7bc16dff8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga184da4166c8b5409dc4b98d7bc16dff8">◆ </a></span>mem_fun2() <span class="overload">[5/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor2.html">bound_const_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2> sigc::mem_fun2 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2) const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor2.html" title="bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance.">sigc::bound_const_mem_functor2</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000076">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga184da4166c8b5409dc4b98d7bc16dff8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga184da4166c8b5409dc4b98d7bc16dff8">◆ </a></span>mem_fun2() <span class="overload">[6/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html">bound_volatile_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2> sigc::mem_fun2 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2) volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor2.html" title="bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance.">sigc::bound_volatile_mem_functor2</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000084">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gab76f41aeada332b353b6fe2e96008831"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gab76f41aeada332b353b6fe2e96008831">◆ </a></span>mem_fun2() <span class="overload">[7/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor2.html">const_volatile_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2> sigc::mem_fun2 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2) const volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor2.html" title="const_volatile_mem_functor2 wraps const volatile methods with 2 argument(s).">sigc::const_volatile_mem_functor2</a> which wraps a const volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gab76f41aeada332b353b6fe2e96008831"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gab76f41aeada332b353b6fe2e96008831">◆ </a></span>mem_fun2() <span class="overload">[8/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor2.html">const_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2> sigc::mem_fun2 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2) const </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor2.html" title="const_mem_functor2 wraps const methods with 2 argument(s).">sigc::const_mem_functor2</a> which wraps a const method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gab76f41aeada332b353b6fe2e96008831"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gab76f41aeada332b353b6fe2e96008831">◆ </a></span>mem_fun2() <span class="overload">[9/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor2.html">volatile_mem_functor2</a><T_return, T_obj, T_arg1, T_arg2> sigc::mem_fun2 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2) volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor2.html" title="volatile_mem_functor2 wraps volatile methods with 2 argument(s).">sigc::volatile_mem_functor2</a> which wraps a volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga14e07df139b5cb6897e671c50fc33cde"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga14e07df139b5cb6897e671c50fc33cde">◆ </a></span>mem_fun3() <span class="overload">[1/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">bound_const_volatile_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3> sigc::mem_fun3 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3) const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html" title="bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object...">sigc::bound_const_volatile_mem_functor3</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga14e07df139b5cb6897e671c50fc33cde"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga14e07df139b5cb6897e671c50fc33cde">◆ </a></span>mem_fun3() <span class="overload">[2/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html">bound_const_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3> sigc::mem_fun3 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3) const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor3.html" title="bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance.">sigc::bound_const_mem_functor3</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga14e07df139b5cb6897e671c50fc33cde"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga14e07df139b5cb6897e671c50fc33cde">◆ </a></span>mem_fun3() <span class="overload">[3/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">bound_volatile_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3> sigc::mem_fun3 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3) volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html" title="bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance.">sigc::bound_volatile_mem_functor3</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga4f2fdbf02e8cac9492326a4a8ffdd012"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga4f2fdbf02e8cac9492326a4a8ffdd012">◆ </a></span>mem_fun3() <span class="overload">[4/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html">bound_const_volatile_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3> sigc::mem_fun3 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3) const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor3.html" title="bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object...">sigc::bound_const_volatile_mem_functor3</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000093">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga4f2fdbf02e8cac9492326a4a8ffdd012"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga4f2fdbf02e8cac9492326a4a8ffdd012">◆ </a></span>mem_fun3() <span class="overload">[5/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor3.html">bound_const_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3> sigc::mem_fun3 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3) const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor3.html" title="bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance.">sigc::bound_const_mem_functor3</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000077">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga4f2fdbf02e8cac9492326a4a8ffdd012"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga4f2fdbf02e8cac9492326a4a8ffdd012">◆ </a></span>mem_fun3() <span class="overload">[6/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html">bound_volatile_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3> sigc::mem_fun3 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3) volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor3.html" title="bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance.">sigc::bound_volatile_mem_functor3</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000085">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga2379e0d689fe4a99c7c669fc29817457"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga2379e0d689fe4a99c7c669fc29817457">◆ </a></span>mem_fun3() <span class="overload">[7/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor3.html">const_volatile_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3> sigc::mem_fun3 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3) const volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor3.html" title="const_volatile_mem_functor3 wraps const volatile methods with 3 argument(s).">sigc::const_volatile_mem_functor3</a> which wraps a const volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga2379e0d689fe4a99c7c669fc29817457"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga2379e0d689fe4a99c7c669fc29817457">◆ </a></span>mem_fun3() <span class="overload">[8/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor3.html">const_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3> sigc::mem_fun3 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3) const </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor3.html" title="const_mem_functor3 wraps const methods with 3 argument(s).">sigc::const_mem_functor3</a> which wraps a const method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga2379e0d689fe4a99c7c669fc29817457"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga2379e0d689fe4a99c7c669fc29817457">◆ </a></span>mem_fun3() <span class="overload">[9/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor3.html">volatile_mem_functor3</a><T_return, T_obj, T_arg1, T_arg2, T_arg3> sigc::mem_fun3 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3) volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor3.html" title="volatile_mem_functor3 wraps volatile methods with 3 argument(s).">sigc::volatile_mem_functor3</a> which wraps a volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga86da5637e2735480d525ffa930e7e21a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga86da5637e2735480d525ffa930e7e21a">◆ </a></span>mem_fun4() <span class="overload">[1/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">bound_const_volatile_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> sigc::mem_fun4 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html" title="bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object...">sigc::bound_const_volatile_mem_functor4</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga86da5637e2735480d525ffa930e7e21a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga86da5637e2735480d525ffa930e7e21a">◆ </a></span>mem_fun4() <span class="overload">[2/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html">bound_const_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> sigc::mem_fun4 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4) const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor4.html" title="bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance.">sigc::bound_const_mem_functor4</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga86da5637e2735480d525ffa930e7e21a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga86da5637e2735480d525ffa930e7e21a">◆ </a></span>mem_fun4() <span class="overload">[3/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">bound_volatile_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> sigc::mem_fun4 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4) volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html" title="bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance.">sigc::bound_volatile_mem_functor4</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga94a2525ef116e16598b81b853544a170"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga94a2525ef116e16598b81b853544a170">◆ </a></span>mem_fun4() <span class="overload">[4/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html">bound_const_volatile_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> sigc::mem_fun4 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor4.html" title="bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object...">sigc::bound_const_volatile_mem_functor4</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000094">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga94a2525ef116e16598b81b853544a170"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga94a2525ef116e16598b81b853544a170">◆ </a></span>mem_fun4() <span class="overload">[5/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor4.html">bound_const_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> sigc::mem_fun4 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4) const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor4.html" title="bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance.">sigc::bound_const_mem_functor4</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000078">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga94a2525ef116e16598b81b853544a170"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga94a2525ef116e16598b81b853544a170">◆ </a></span>mem_fun4() <span class="overload">[6/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html">bound_volatile_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> sigc::mem_fun4 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4) volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor4.html" title="bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance.">sigc::bound_volatile_mem_functor4</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000086">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga1bedd04f76ad3e21f614912562e95d83"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga1bedd04f76ad3e21f614912562e95d83">◆ </a></span>mem_fun4() <span class="overload">[7/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor4.html">const_volatile_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> sigc::mem_fun4 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor4.html" title="const_volatile_mem_functor4 wraps const volatile methods with 4 argument(s).">sigc::const_volatile_mem_functor4</a> which wraps a const volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga1bedd04f76ad3e21f614912562e95d83"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga1bedd04f76ad3e21f614912562e95d83">◆ </a></span>mem_fun4() <span class="overload">[8/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor4.html">const_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> sigc::mem_fun4 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4) const </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor4.html" title="const_mem_functor4 wraps const methods with 4 argument(s).">sigc::const_mem_functor4</a> which wraps a const method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga1bedd04f76ad3e21f614912562e95d83"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga1bedd04f76ad3e21f614912562e95d83">◆ </a></span>mem_fun4() <span class="overload">[9/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor4.html">volatile_mem_functor4</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> sigc::mem_fun4 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4) volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor4.html" title="volatile_mem_functor4 wraps volatile methods with 4 argument(s).">sigc::volatile_mem_functor4</a> which wraps a volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga5c2ca9cef8c857935a59133a73ef61f2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga5c2ca9cef8c857935a59133a73ef61f2">◆ </a></span>mem_fun5() <span class="overload">[1/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">bound_const_volatile_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> sigc::mem_fun5 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html" title="bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object...">sigc::bound_const_volatile_mem_functor5</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga5c2ca9cef8c857935a59133a73ef61f2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga5c2ca9cef8c857935a59133a73ef61f2">◆ </a></span>mem_fun5() <span class="overload">[2/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html">bound_const_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> sigc::mem_fun5 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor5.html" title="bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance.">sigc::bound_const_mem_functor5</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga5c2ca9cef8c857935a59133a73ef61f2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga5c2ca9cef8c857935a59133a73ef61f2">◆ </a></span>mem_fun5() <span class="overload">[3/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">bound_volatile_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> sigc::mem_fun5 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html" title="bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance.">sigc::bound_volatile_mem_functor5</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaf060fe3a2be4ff7c0f50aef54b4dc8bf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaf060fe3a2be4ff7c0f50aef54b4dc8bf">◆ </a></span>mem_fun5() <span class="overload">[4/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html">bound_const_volatile_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> sigc::mem_fun5 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor5.html" title="bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object...">sigc::bound_const_volatile_mem_functor5</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000095">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaf060fe3a2be4ff7c0f50aef54b4dc8bf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaf060fe3a2be4ff7c0f50aef54b4dc8bf">◆ </a></span>mem_fun5() <span class="overload">[5/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor5.html">bound_const_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> sigc::mem_fun5 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor5.html" title="bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance.">sigc::bound_const_mem_functor5</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000079">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gaf060fe3a2be4ff7c0f50aef54b4dc8bf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gaf060fe3a2be4ff7c0f50aef54b4dc8bf">◆ </a></span>mem_fun5() <span class="overload">[6/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html">bound_volatile_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> sigc::mem_fun5 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor5.html" title="bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance.">sigc::bound_volatile_mem_functor5</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000087">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga3ef4bb904a751d29e2b6803ef81f72fa"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga3ef4bb904a751d29e2b6803ef81f72fa">◆ </a></span>mem_fun5() <span class="overload">[7/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor5.html">const_volatile_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> sigc::mem_fun5 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor5.html" title="const_volatile_mem_functor5 wraps const volatile methods with 5 argument(s).">sigc::const_volatile_mem_functor5</a> which wraps a const volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga3ef4bb904a751d29e2b6803ef81f72fa"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga3ef4bb904a751d29e2b6803ef81f72fa">◆ </a></span>mem_fun5() <span class="overload">[8/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor5.html">const_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> sigc::mem_fun5 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor5.html" title="const_mem_functor5 wraps const methods with 5 argument(s).">sigc::const_mem_functor5</a> which wraps a const method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga3ef4bb904a751d29e2b6803ef81f72fa"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga3ef4bb904a751d29e2b6803ef81f72fa">◆ </a></span>mem_fun5() <span class="overload">[9/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor5.html">volatile_mem_functor5</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> sigc::mem_fun5 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor5.html" title="volatile_mem_functor5 wraps volatile methods with 5 argument(s).">sigc::volatile_mem_functor5</a> which wraps a volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga947f4410e62a2996023177e490c882b7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga947f4410e62a2996023177e490c882b7">◆ </a></span>mem_fun6() <span class="overload">[1/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">bound_const_volatile_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> sigc::mem_fun6 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html" title="bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object...">sigc::bound_const_volatile_mem_functor6</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga947f4410e62a2996023177e490c882b7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga947f4410e62a2996023177e490c882b7">◆ </a></span>mem_fun6() <span class="overload">[2/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html">bound_const_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> sigc::mem_fun6 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor6.html" title="bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance.">sigc::bound_const_mem_functor6</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga947f4410e62a2996023177e490c882b7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga947f4410e62a2996023177e490c882b7">◆ </a></span>mem_fun6() <span class="overload">[3/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">bound_volatile_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> sigc::mem_fun6 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html" title="bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance.">sigc::bound_volatile_mem_functor6</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gac0a6242da9bf96642f25c1363dfef383"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gac0a6242da9bf96642f25c1363dfef383">◆ </a></span>mem_fun6() <span class="overload">[4/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html">bound_const_volatile_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> sigc::mem_fun6 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor6.html" title="bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object...">sigc::bound_const_volatile_mem_functor6</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000096">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gac0a6242da9bf96642f25c1363dfef383"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gac0a6242da9bf96642f25c1363dfef383">◆ </a></span>mem_fun6() <span class="overload">[5/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor6.html">bound_const_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> sigc::mem_fun6 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor6.html" title="bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance.">sigc::bound_const_mem_functor6</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000080">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="gac0a6242da9bf96642f25c1363dfef383"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#gac0a6242da9bf96642f25c1363dfef383">◆ </a></span>mem_fun6() <span class="overload">[6/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html">bound_volatile_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> sigc::mem_fun6 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor6.html" title="bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance.">sigc::bound_volatile_mem_functor6</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000088">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga34ace98fbbd18cb635795639d0f22678"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga34ace98fbbd18cb635795639d0f22678">◆ </a></span>mem_fun6() <span class="overload">[7/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor6.html">const_volatile_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> sigc::mem_fun6 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor6.html" title="const_volatile_mem_functor6 wraps const volatile methods with 6 argument(s).">sigc::const_volatile_mem_functor6</a> which wraps a const volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga34ace98fbbd18cb635795639d0f22678"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga34ace98fbbd18cb635795639d0f22678">◆ </a></span>mem_fun6() <span class="overload">[8/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor6.html">const_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> sigc::mem_fun6 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor6.html" title="const_mem_functor6 wraps const methods with 6 argument(s).">sigc::const_mem_functor6</a> which wraps a const method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga34ace98fbbd18cb635795639d0f22678"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga34ace98fbbd18cb635795639d0f22678">◆ </a></span>mem_fun6() <span class="overload">[9/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor6.html">volatile_mem_functor6</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> sigc::mem_fun6 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor6.html" title="volatile_mem_functor6 wraps volatile methods with 6 argument(s).">sigc::volatile_mem_functor6</a> which wraps a volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga1f704e475da2aad1717e059c264c1436"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga1f704e475da2aad1717e059c264c1436">◆ </a></span>mem_fun7() <span class="overload">[1/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">bound_const_volatile_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sigc::mem_fun7 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html" title="bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object...">sigc::bound_const_volatile_mem_functor7</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga1f704e475da2aad1717e059c264c1436"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga1f704e475da2aad1717e059c264c1436">◆ </a></span>mem_fun7() <span class="overload">[2/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html">bound_const_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sigc::mem_fun7 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor7.html" title="bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance.">sigc::bound_const_mem_functor7</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga1f704e475da2aad1717e059c264c1436"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga1f704e475da2aad1717e059c264c1436">◆ </a></span>mem_fun7() <span class="overload">[3/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">bound_volatile_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sigc::mem_fun7 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj & </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html" title="bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance.">sigc::bound_volatile_mem_functor7</a> which encapsulates a method and an object instance. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Reference to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga9899534bc8eb78c227d895b396710091"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga9899534bc8eb78c227d895b396710091">◆ </a></span>mem_fun7() <span class="overload">[4/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html">bound_const_volatile_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sigc::mem_fun7 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__volatile__mem__functor7.html" title="bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object...">sigc::bound_const_volatile_mem_functor7</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000097">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga9899534bc8eb78c227d895b396710091"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga9899534bc8eb78c227d895b396710091">◆ </a></span>mem_fun7() <span class="overload">[5/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__const__mem__functor7.html">bound_const_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sigc::mem_fun7 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__const__mem__functor7.html" title="bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance.">sigc::bound_const_mem_functor7</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000081">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga9899534bc8eb78c227d895b396710091"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga9899534bc8eb78c227d895b396710091">◆ </a></span>mem_fun7() <span class="overload">[6/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html">bound_volatile_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sigc::mem_fun7 </td>
+ <td>(</td>
+ <td class="paramtype">T_obj * </td>
+ <td class="paramname"><em>_A_obj</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_return(T_obj2::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile </td>
+ <td class="paramname"><em>_A_func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1bound__volatile__mem__functor7.html" title="bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance.">sigc::bound_volatile_mem_functor7</a> which encapsulates a method and an object instance. </p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000089">Deprecated:</a></b></dt><dd>Please use the version that takes the object by reference instead.</dd></dl>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_obj</td><td>Pointer to object instance the functor should operate on. </td></tr>
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes <em>_A_func</em> on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga3d174b01bf94dbda3aea58c25c2b3322"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga3d174b01bf94dbda3aea58c25c2b3322">◆ </a></span>mem_fun7() <span class="overload">[7/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__volatile__mem__functor7.html">const_volatile_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sigc::mem_fun7 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__volatile__mem__functor7.html" title="const_volatile_mem_functor7 wraps const volatile methods with 7 argument(s).">sigc::const_volatile_mem_functor7</a> which wraps a const volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga3d174b01bf94dbda3aea58c25c2b3322"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga3d174b01bf94dbda3aea58c25c2b3322">◆ </a></span>mem_fun7() <span class="overload">[8/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1const__mem__functor7.html">const_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sigc::mem_fun7 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1const__mem__functor7.html" title="const_mem_functor7 wraps const methods with 7 argument(s).">sigc::const_mem_functor7</a> which wraps a const method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="ga3d174b01bf94dbda3aea58c25c2b3322"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ga3d174b01bf94dbda3aea58c25c2b3322">◆ </a></span>mem_fun7() <span class="overload">[9/9]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1volatile__mem__functor7.html">volatile_mem_functor7</a><T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> sigc::mem_fun7 </td>
+ <td>(</td>
+ <td class="paramtype">T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Creates a functor of type <a class="el" href="classsigc_1_1volatile__mem__functor7.html" title="volatile_mem_functor7 wraps volatile methods with 7 argument(s).">sigc::volatile_mem_functor7</a> which wraps a volatile method. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Pointer to method that should be wrapped. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>Functor that executes _A_func on invokation. </dd></dl>
+
+</div>
+</div>
+<a id="a670882bd3fa5890b464871ac515aaba9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a670882bd3fa5890b464871ac515aaba9">◆ </a></span>ref() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1const__reference__wrapper.html">const_reference_wrapper</a><T_type> sigc::ref </td>
+ <td>(</td>
+ <td class="paramtype">const T_type & </td>
+ <td class="paramname"><em>v</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+<p>Creates a const reference wrapper. </p>
+<p>Passing an object throught <a class="el" href="namespacesigc.html#a48e982c74c057b5630246ba436524041" title="Creates a reference wrapper.">sigc::ref()</a> makes libsigc++ adaptors like, e.g., <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">sigc::bind</a> store references to the object instead of copies. If the object type inherits from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> this will ensure automatic invalidation of the adaptors when the object is deleted or overwritten.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">v</td><td>Reference to store. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>A reference wrapper.</dd></dl>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000205">Deprecated:</a></b></dt><dd>Use std::ref() or std::cref() instead. </dd></dl>
+
+</div>
+</div>
+<a id="a48e982c74c057b5630246ba436524041"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a48e982c74c057b5630246ba436524041">◆ </a></span>ref() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1reference__wrapper.html">reference_wrapper</a><T_type> sigc::ref </td>
+ <td>(</td>
+ <td class="paramtype">T_type & </td>
+ <td class="paramname"><em>v</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+<p>Creates a reference wrapper. </p>
+<p>Passing an object throught <a class="el" href="namespacesigc.html#a48e982c74c057b5630246ba436524041" title="Creates a reference wrapper.">sigc::ref()</a> makes libsigc++ adaptors like, e.g., <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">sigc::bind</a> store references to the object instead of copies. If the object type inherits from <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> this will ensure automatic invalidation of the adaptors when the object is deleted or overwritten.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">v</td><td>Reference to store. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>A reference wrapper.</dd></dl>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000204">Deprecated:</a></b></dt><dd>Use std::ref() or std::cref() instead. </dd></dl>
+
+</div>
+</div>
+<a id="a2f758c77e8743093f938d0c5dbf06778"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2f758c77e8743093f938d0c5dbf06778">◆ </a></span>unwrap() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">const T_type& sigc::unwrap </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="structsigc_1_1const__reference__wrapper.html">const_reference_wrapper</a>< T_type > & </td>
+ <td class="paramname"><em>v</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a3b5529822bdaf60f07456633e0f40282"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3b5529822bdaf60f07456633e0f40282">◆ </a></span>unwrap() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">T_type& sigc::unwrap </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="structsigc_1_1reference__wrapper.html">reference_wrapper</a>< T_type > & </td>
+ <td class="paramname"><em>v</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a3256789f3d3bb134471d7cf8fcf4d91a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3256789f3d3bb134471d7cf8fcf4d91a">◆ </a></span>unwrap() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">T_type& sigc::unwrap </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a03225.html">std::reference_wrapper</a>< T_type > & </td>
+ <td class="paramname"><em>v</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Related Pages</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">Related Pages</div> </div>
+</div><!--header-->
+<div class="contents">
+<div class="textblock">Here is a list of all related documentation pages:</div><div class="directory">
+<table class="directory">
+<tr id="row_0_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><a class="el" href="deprecated.html" target="_self">Deprecated List</a></td><td class="desc"></td></tr>
+<tr id="row_1_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><a class="el" href="since_2_8.html" target="_self">New API in libsigc++ 2.8</a></td><td class="desc"></td></tr>
+<tr id="row_2_" class="even"><td class="entry"><span style="width:16px;display:inline-block;"> </span><a class="el" href="since_2_4.html" target="_self">New API in libsigc++ 2.4</a></td><td class="desc"></td></tr>
+<tr id="row_3_"><td class="entry"><span style="width:16px;display:inline-block;"> </span><a class="el" href="since_2_2_11.html" target="_self">New API in libsigc++ 2.2.11</a></td><td class="desc"></td></tr>
+</table>
+</div><!-- directory -->
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: New API in libsigc++ 2.2.11</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="PageDoc"><div class="header">
+ <div class="headertitle">
+<div class="title">New API in libsigc++ 2.2.11 </div> </div>
+</div><!--header-->
+<div class="contents">
+<div class="textblock"><dl class="reflist">
+<dt>Member <a class="el" href="group__sigcfunctors.html#gadf1ba3cacb09cc5c3c3e399836ec6e50">SIGC_FUNCTORS_DEDUCE_RESULT_TYPE_WITH_DECLTYPE</a> </dt>
+<dd><a class="anchor" id="_since_2_2_11000001"></a></dd>
+</dl>
+</div></div><!-- contents -->
+</div><!-- PageDoc -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: New API in libsigc++ 2.4</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="PageDoc"><div class="header">
+ <div class="headertitle">
+<div class="title">New API in libsigc++ 2.4 </div> </div>
+</div><!--header-->
+<div class="contents">
+<div class="textblock"><dl class="reflist">
+<dt>Member <a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">sigc::signal_base::block</a> (bool should_block=true) noexcept</dt>
+<dd><a class="anchor" id="_since_2_4000019"></a> </dd>
+<dt>Member <a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">sigc::signal_base::blocked</a> () const noexcept</dt>
+<dd><a class="anchor" id="_since_2_4000018"></a> </dd>
+<dt>Member <a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">sigc::signal_base::unblock</a> () noexcept</dt>
+<dd><a class="anchor" id="_since_2_4000020"></a> </dd>
+<dt>Member <a class="el" href="group__track__obj.html#ga52b11304cb05441237a8dcc651cb724e">sigc::track_obj</a> (const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2, const T_obj3 & _A_obj3)</dt>
+<dd><a class="anchor" id="_since_2_4000011"></a> </dd>
+<dt>Member <a class="el" href="group__track__obj.html#ga5ea3e9f52643d7ab1bcfa4f419e7d38f">sigc::track_obj</a> (const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2, const T_obj3 & _A_obj3, const T_obj4 & _A_obj4, const T_obj5 & _A_obj5, const T_obj6 & _A_obj6, const T_obj7 & _A_obj7)</dt>
+<dd><a class="anchor" id="_since_2_4000015"></a> </dd>
+<dt>Member <a class="el" href="group__track__obj.html#ga0304ca1269ed352fcc1c81324062302e">sigc::track_obj</a> (const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2, const T_obj3 & _A_obj3, const T_obj4 & _A_obj4, const T_obj5 & _A_obj5, const T_obj6 & _A_obj6)</dt>
+<dd><a class="anchor" id="_since_2_4000014"></a> </dd>
+<dt>Member <a class="el" href="group__track__obj.html#ga337dc48ba1e394f572d5d914b83f57a0">sigc::track_obj</a> (const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2, const T_obj3 & _A_obj3, const T_obj4 & _A_obj4, const T_obj5 & _A_obj5)</dt>
+<dd><a class="anchor" id="_since_2_4000013"></a> </dd>
+<dt>Member <a class="el" href="group__track__obj.html#gaea44f2388c18ca8508818ff6b7756216">sigc::track_obj</a> (const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2, const T_obj3 & _A_obj3, const T_obj4 & _A_obj4)</dt>
+<dd><a class="anchor" id="_since_2_4000012"></a> </dd>
+<dt>Member <a class="el" href="group__track__obj.html#ga60842510c2387ec49c43149d94fb1b72">sigc::track_obj</a> (const T_functor & _A_func, const T_obj1 & _A_obj1, const T_obj2 & _A_obj2)</dt>
+<dd><a class="anchor" id="_since_2_4000010"></a> </dd>
+<dt>Member <a class="el" href="group__track__obj.html#ga8fd1ab36d123ff83dd4cd8dc58bb28e2">sigc::track_obj</a> (const T_functor & _A_func, const T_obj1 & _A_obj1)</dt>
+<dd><a class="anchor" id="_since_2_4000009"></a> </dd>
+<dt>Class <a class="el" href="classsigc_1_1track__obj__functor1.html">sigc::track_obj_functor1< T_functor, T_obj1 ></a> </dt>
+<dd><a class="anchor" id="_since_2_4000002"></a> </dd>
+<dt>Class <a class="el" href="classsigc_1_1track__obj__functor2.html">sigc::track_obj_functor2< T_functor, T_obj1, T_obj2 ></a> </dt>
+<dd><a class="anchor" id="_since_2_4000003"></a> </dd>
+<dt>Class <a class="el" href="classsigc_1_1track__obj__functor3.html">sigc::track_obj_functor3< T_functor, T_obj1, T_obj2, T_obj3 ></a> </dt>
+<dd><a class="anchor" id="_since_2_4000004"></a> </dd>
+<dt>Class <a class="el" href="classsigc_1_1track__obj__functor4.html">sigc::track_obj_functor4< T_functor, T_obj1, T_obj2, T_obj3, T_obj4 ></a> </dt>
+<dd><a class="anchor" id="_since_2_4000005"></a> </dd>
+<dt>Class <a class="el" href="classsigc_1_1track__obj__functor5.html">sigc::track_obj_functor5< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5 ></a> </dt>
+<dd><a class="anchor" id="_since_2_4000006"></a> </dd>
+<dt>Class <a class="el" href="classsigc_1_1track__obj__functor6.html">sigc::track_obj_functor6< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6 ></a> </dt>
+<dd><a class="anchor" id="_since_2_4000007"></a> </dd>
+<dt>Class <a class="el" href="classsigc_1_1track__obj__functor7.html">sigc::track_obj_functor7< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6, T_obj7 ></a> </dt>
+<dd><a class="anchor" id="_since_2_4000008"></a> </dd>
+<dt>Module <a class="el" href="group__track__obj.html">track_obj</a> </dt>
+<dd><a class="anchor" id="_since_2_4000001"></a></dd>
+</dl>
+</div></div><!-- contents -->
+</div><!-- PageDoc -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: New API in libsigc++ 2.8</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<div class="PageDoc"><div class="header">
+ <div class="headertitle">
+<div class="title">New API in libsigc++ 2.8 </div> </div>
+</div><!--header-->
+<div class="contents">
+<div class="textblock"><dl class="reflist">
+<dt>Member <a class="el" href="classsigc_1_1signal0.html#a9b78954271b6dba5e926bd960f3e7905">sigc::signal0< T_return, T_accumulator >::connect</a> (slot_type && slot_)</dt>
+<dd><a class="anchor" id="_since_2_8000001"></a> </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal1.html#ac69d2681c586b310d8c056a319bb65fe">sigc::signal1< T_return, T_arg1, T_accumulator >::connect</a> (slot_type && slot_)</dt>
+<dd><a class="anchor" id="_since_2_8000002"></a> </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal2.html#ab89b1876c69ea40954b0af37e75a21b4">sigc::signal2< T_return, T_arg1, T_arg2, T_accumulator >::connect</a> (slot_type && slot_)</dt>
+<dd><a class="anchor" id="_since_2_8000003"></a> </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal3.html#ad71389c6d6ea60e745897579b3344d00">sigc::signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::connect</a> (slot_type && slot_)</dt>
+<dd><a class="anchor" id="_since_2_8000004"></a> </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal4.html#a5c8d2d9c91a134650a52631d49ecdaac">sigc::signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::connect</a> (slot_type && slot_)</dt>
+<dd><a class="anchor" id="_since_2_8000005"></a> </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal5.html#a05cfed3d3e29158424bc810168d78153">sigc::signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::connect</a> (slot_type && slot_)</dt>
+<dd><a class="anchor" id="_since_2_8000006"></a> </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal6.html#a1754aa5a8959da0bb55e42864a8365af">sigc::signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::connect</a> (slot_type && slot_)</dt>
+<dd><a class="anchor" id="_since_2_8000007"></a> </dd>
+<dt>Member <a class="el" href="classsigc_1_1signal7.html#a5aed4bdb8d85c3d854f01410d2d9d3a4">sigc::signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::connect</a> (slot_type && slot_)</dt>
+<dd><a class="anchor" id="_since_2_8000008"></a> </dd>
+<dt>Member <a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">sigc::signal_base::connect</a> (<a class="el" href="classsigc_1_1slot__base.html" title="Base type for slots.">slot_base</a> && slot_)</dt>
+<dd><a class="anchor" id="_since_2_8000011"></a> </dd>
+<dt>Member <a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">sigc::signal_base::insert</a> (iterator_type i, <a class="el" href="classsigc_1_1slot__base.html" title="Base type for slots.">slot_base</a> && slot_)</dt>
+<dd><a class="anchor" id="_since_2_8000012"></a> </dd>
+</dl>
+</div></div><!-- contents -->
+</div><!-- PageDoc -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::adaptor_base Struct Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1adaptor__base.html">adaptor_base</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::adaptor_base Struct Reference<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>A hint to the compiler.
+ <a href="structsigc_1_1adaptor__base.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/deduce_result_type.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::adaptor_base:</div>
+<div class="dyncontent">
+<div class="center"><img src="structsigc_1_1adaptor__base__inherit__graph.png" border="0" usemap="#asigc_1_1adaptor__base_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1adaptor__base_inherit__map" id="asigc_1_1adaptor__base_inherit__map">
+<area shape="rect" title="A hint to the compiler." alt="" coords="193,297,337,323"/>
+<area shape="rect" href="structsigc_1_1adapts.html" title=" " alt="" coords="389,86,572,113"/>
+<area shape="rect" href="structsigc_1_1adaptor__functor.html" title="Converts an arbitrary functor into an adaptor type." alt="" coords="401,289,560,331"/>
+<area shape="rect" href="structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="385,509,576,535"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,297,145,323"/>
+<area shape="rect" href="structsigc_1_1compose1__functor.html" title="Adaptor that combines two functors." alt="" coords="643,5,819,47"/>
+<area shape="rect" href="structsigc_1_1compose2__functor.html" title="Adaptor that combines three functors." alt="" coords="643,71,819,127"/>
+<area shape="rect" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Adaptor that binds an argument to the wrapped functor." alt="" coords="640,151,821,207"/>
+<area shape="rect" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Adaptor that binds 1 argument(s) to the wrapped functor." alt="" coords="641,231,820,287"/>
+<area shape="rect" href="structsigc_1_1bind__return__functor.html" title="Adaptor that fixes the return value of the wrapped functor." alt="" coords="639,312,822,353"/>
+<area shape="rect" href="structsigc_1_1exception__catch__functor.html" title=" " alt="" coords="647,378,814,434"/>
+<area shape="rect" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html" title=" " alt="" coords="649,458,812,514"/>
+<area shape="rect" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html" title="Adaptor that adds a dummy parameter to the wrapped functor." alt="" coords="662,539,799,580"/>
+<area shape="rect" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html" title="Adaptor that adds a dummy parameter to the wrapped functor." alt="" coords="662,604,799,645"/>
+<area shape="rect" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor." alt="" coords="624,669,837,740"/>
+<area shape="rect" href="structsigc_1_1retype__return__functor.html" title="Adaptor that performs a C-style cast on the return value of a functor." alt="" coords="657,765,805,821"/>
+<area shape="rect" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html" title="Adaptor that performs a C-style cast on the return value of a functor." alt="" coords="629,845,832,887"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object." alt="" coords="642,911,819,952"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor2.html" title="track_obj_functor2 wraps a functor and stores 2 references to trackable objects." alt="" coords="891,717,1105,759"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor3.html" title="track_obj_functor3 wraps a functor and stores 3 references to trackable objects." alt="" coords="909,783,1087,839"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor4.html" title="track_obj_functor4 wraps a functor and stores 4 references to trackable objects." alt="" coords="909,863,1087,919"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor5.html" title="track_obj_functor5 wraps a functor and stores 5 references to trackable objects." alt="" coords="885,943,1111,999"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor6.html" title="track_obj_functor6 wraps a functor and stores 6 references to trackable objects." alt="" coords="909,1024,1087,1095"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor7.html" title="track_obj_functor7 wraps a functor and stores 7 references to trackable objects." alt="" coords="909,1119,1087,1189"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><p>A hint to the compiler. </p>
+<p>Functors which have all methods based on templates should publicly inherit from this hint and define a nested template class <code><a class="el" href="structsigc_1_1deduce__result__type.html" title="Deduce the return type of a functor.">deduce_result_type</a></code> that can be used to deduce the methods' return types.</p>
+<p><a class="el" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler.">adaptor_base</a> inherits from the <a class="el" href="structsigc_1_1functor__base.html" title="A hint to the compiler.">functor_base</a> hint so derived types should also have a result_type defined.</p>
+<p>Adaptors don't inherit from this type directly. They use use <a class="el" href="structsigc_1_1adapts.html" title="Base type for adaptors.">sigc::adapts</a> as a base type instead. sigc::adaptors wraps arbitrary functor types as well as function pointers and class methods. </p>
+</div></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::adaptor_base" name="sigc::adaptor_base">
+<area shape="rect" id="node1" title="A hint to the compiler." alt="" coords="193,297,337,323"/>
+<area shape="rect" id="node3" href="$structsigc_1_1adapts.html" title=" " alt="" coords="389,86,572,113"/>
+<area shape="rect" id="node6" href="$structsigc_1_1adaptor__functor.html" title="Converts an arbitrary functor into an adaptor type." alt="" coords="401,289,560,331"/>
+<area shape="rect" id="node7" href="$structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="385,509,576,535"/>
+<area shape="rect" id="node2" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,297,145,323"/>
+<area shape="rect" id="node4" href="$structsigc_1_1compose1__functor.html" title="Adaptor that combines two functors." alt="" coords="643,5,819,47"/>
+<area shape="rect" id="node5" href="$structsigc_1_1compose2__functor.html" title="Adaptor that combines three functors." alt="" coords="643,71,819,127"/>
+<area shape="rect" id="node8" href="$structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Adaptor that binds an argument to the wrapped functor." alt="" coords="640,151,821,207"/>
+<area shape="rect" id="node9" href="$structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Adaptor that binds 1 argument(s) to the wrapped functor." alt="" coords="641,231,820,287"/>
+<area shape="rect" id="node10" href="$structsigc_1_1bind__return__functor.html" title="Adaptor that fixes the return value of the wrapped functor." alt="" coords="639,312,822,353"/>
+<area shape="rect" id="node11" href="$structsigc_1_1exception__catch__functor.html" title=" " alt="" coords="647,378,814,434"/>
+<area shape="rect" id="node12" href="$structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html" title=" " alt="" coords="649,458,812,514"/>
+<area shape="rect" id="node13" href="$structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html" title="Adaptor that adds a dummy parameter to the wrapped functor." alt="" coords="662,539,799,580"/>
+<area shape="rect" id="node14" href="$structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html" title="Adaptor that adds a dummy parameter to the wrapped functor." alt="" coords="662,604,799,645"/>
+<area shape="rect" id="node15" href="$structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor." alt="" coords="624,669,837,740"/>
+<area shape="rect" id="node16" href="$structsigc_1_1retype__return__functor.html" title="Adaptor that performs a C-style cast on the return value of a functor." alt="" coords="657,765,805,821"/>
+<area shape="rect" id="node17" href="$structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html" title="Adaptor that performs a C-style cast on the return value of a functor." alt="" coords="629,845,832,887"/>
+<area shape="rect" id="node18" href="$classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object." alt="" coords="642,911,819,952"/>
+<area shape="rect" id="node19" href="$classsigc_1_1track__obj__functor2.html" title="track_obj_functor2 wraps a functor and stores 2 references to trackable objects." alt="" coords="891,717,1105,759"/>
+<area shape="rect" id="node20" href="$classsigc_1_1track__obj__functor3.html" title="track_obj_functor3 wraps a functor and stores 3 references to trackable objects." alt="" coords="909,783,1087,839"/>
+<area shape="rect" id="node21" href="$classsigc_1_1track__obj__functor4.html" title="track_obj_functor4 wraps a functor and stores 4 references to trackable objects." alt="" coords="909,863,1087,919"/>
+<area shape="rect" id="node22" href="$classsigc_1_1track__obj__functor5.html" title="track_obj_functor5 wraps a functor and stores 5 references to trackable objects." alt="" coords="885,943,1111,999"/>
+<area shape="rect" id="node23" href="$classsigc_1_1track__obj__functor6.html" title="track_obj_functor6 wraps a functor and stores 6 references to trackable objects." alt="" coords="909,1024,1087,1095"/>
+<area shape="rect" id="node24" href="$classsigc_1_1track__obj__functor7.html" title="track_obj_functor7 wraps a functor and stores 7 references to trackable objects." alt="" coords="909,1119,1087,1189"/>
+</map>
--- /dev/null
+219852521bd8ba759facfd5a61216b07
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1adaptor__functor.html">adaptor_functor</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::adaptor_functor< T_functor > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1adaptor__functor.html">sigc::adaptor_functor< T_functor ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adaptor__functor.html#a39ef4610f8e0f03425b6f4a44b59e5fb">adaptor_functor</a>()</td><td class="entry"><a class="el" href="structsigc_1_1adaptor__functor.html">sigc::adaptor_functor< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adaptor__functor.html#ac5907212f7ee2eadf10b31757a0c5930">adaptor_functor</a>(const T_functor & _A_functor)</td><td class="entry"><a class="el" href="structsigc_1_1adaptor__functor.html">sigc::adaptor_functor< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adaptor__functor.html#af765e401002eb15f18aca5cfaa678b01">adaptor_functor</a>(const T_type & _A_type)</td><td class="entry"><a class="el" href="structsigc_1_1adaptor__functor.html">sigc::adaptor_functor< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adaptor__functor.html#a4faff6b7a82f4f6d92e3d3b0aa8fdca8">functor_</a></td><td class="entry"><a class="el" href="structsigc_1_1adaptor__functor.html">sigc::adaptor_functor< T_functor ></a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adaptor__functor.html#aa8f3859324cce86596f0eb81b7bb6037">operator()</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1adaptor__functor.html">sigc::adaptor_functor< T_functor ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adaptor__functor.html#ad5f69b862958bf7c45e7f6d3bc5f4c6e">operator()</a>(T_arg1 _A_arg1) const</td><td class="entry"><a class="el" href="structsigc_1_1adaptor__functor.html">sigc::adaptor_functor< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adaptor__functor.html#aab920cf1b05ce5d6c9513aa18323ea2a">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2) const</td><td class="entry"><a class="el" href="structsigc_1_1adaptor__functor.html">sigc::adaptor_functor< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adaptor__functor.html#a0da9456dab8a22caffe6cfd624e32e30">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3) const</td><td class="entry"><a class="el" href="structsigc_1_1adaptor__functor.html">sigc::adaptor_functor< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adaptor__functor.html#a2b393cd9388414a1a6ad7148eec4354a">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4) const</td><td class="entry"><a class="el" href="structsigc_1_1adaptor__functor.html">sigc::adaptor_functor< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adaptor__functor.html#a9bec9cfe2f00505a35cdb2b8d5117b09">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5) const</td><td class="entry"><a class="el" href="structsigc_1_1adaptor__functor.html">sigc::adaptor_functor< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adaptor__functor.html#a824de5f3164f45f78ea3771743b94ca4">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6) const</td><td class="entry"><a class="el" href="structsigc_1_1adaptor__functor.html">sigc::adaptor_functor< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adaptor__functor.html#a5be4edc8ea900c6454cb024836b9f655">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6, T_arg7 _A_arg7) const</td><td class="entry"><a class="el" href="structsigc_1_1adaptor__functor.html">sigc::adaptor_functor< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adaptor__functor.html#adc1e7ebba9db294494c62666e10b719b">result_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1adaptor__functor.html">sigc::adaptor_functor< T_functor ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::adaptor_functor< T_functor > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1adaptor__functor.html">adaptor_functor</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="structsigc_1_1adaptor__functor-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::adaptor_functor< T_functor > Struct Template Reference<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Converts an arbitrary functor into an adaptor type.
+ <a href="structsigc_1_1adaptor__functor.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/adaptor_trait.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::adaptor_functor< T_functor >:</div>
+<div class="dyncontent">
+<div class="center"><img src="structsigc_1_1adaptor__functor__inherit__graph.png" border="0" usemap="#asigc_1_1adaptor__functor_3_01T__functor_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1adaptor__functor_3_01T__functor_01_4_inherit__map" id="asigc_1_1adaptor__functor_3_01T__functor_01_4_inherit__map">
+<area shape="rect" title="Converts an arbitrary functor into an adaptor type." alt="" coords="5,155,164,196"/>
+<area shape="rect" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="13,80,157,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="15,5,155,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:adc1e7ebba9db294494c62666e10b719b"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1functor__trait.html">functor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adaptor__functor.html#adc1e7ebba9db294494c62666e10b719b">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adaptor__functor.html#adc1e7ebba9db294494c62666e10b719b">result_type</a></td></tr>
+<tr class="separator:adc1e7ebba9db294494c62666e10b719b"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a39ef4610f8e0f03425b6f4a44b59e5fb"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adaptor__functor.html#a39ef4610f8e0f03425b6f4a44b59e5fb">adaptor_functor</a> ()</td></tr>
+<tr class="memdesc:a39ef4610f8e0f03425b6f4a44b59e5fb"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an invalid functor. <a href="structsigc_1_1adaptor__functor.html#a39ef4610f8e0f03425b6f4a44b59e5fb">More...</a><br /></td></tr>
+<tr class="separator:a39ef4610f8e0f03425b6f4a44b59e5fb"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac5907212f7ee2eadf10b31757a0c5930"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adaptor__functor.html#ac5907212f7ee2eadf10b31757a0c5930">adaptor_functor</a> (const T_functor & _A_functor)</td></tr>
+<tr class="memdesc:ac5907212f7ee2eadf10b31757a0c5930"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an <a class="el" href="structsigc_1_1adaptor__functor.html" title="Converts an arbitrary functor into an adaptor type.">adaptor_functor</a> object that wraps the passed functor. <a href="structsigc_1_1adaptor__functor.html#ac5907212f7ee2eadf10b31757a0c5930">More...</a><br /></td></tr>
+<tr class="separator:ac5907212f7ee2eadf10b31757a0c5930"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af765e401002eb15f18aca5cfaa678b01"><td class="memTemplParams" colspan="2">template<class T_type > </td></tr>
+<tr class="memitem:af765e401002eb15f18aca5cfaa678b01"><td class="memTemplItemLeft" align="right" valign="top"> </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1adaptor__functor.html#af765e401002eb15f18aca5cfaa678b01">adaptor_functor</a> (const T_type & _A_type)</td></tr>
+<tr class="memdesc:af765e401002eb15f18aca5cfaa678b01"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an <a class="el" href="structsigc_1_1adaptor__functor.html" title="Converts an arbitrary functor into an adaptor type.">adaptor_functor</a> object that wraps the passed (member) function pointer. <a href="structsigc_1_1adaptor__functor.html#af765e401002eb15f18aca5cfaa678b01">More...</a><br /></td></tr>
+<tr class="separator:af765e401002eb15f18aca5cfaa678b01"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa8f3859324cce86596f0eb81b7bb6037"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adaptor__functor.html#adc1e7ebba9db294494c62666e10b719b">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adaptor__functor.html#aa8f3859324cce86596f0eb81b7bb6037">operator()</a> () const</td></tr>
+<tr class="memdesc:aa8f3859324cce86596f0eb81b7bb6037"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="structsigc_1_1adaptor__functor.html#aa8f3859324cce86596f0eb81b7bb6037">More...</a><br /></td></tr>
+<tr class="separator:aa8f3859324cce86596f0eb81b7bb6037"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad5f69b862958bf7c45e7f6d3bc5f4c6e"><td class="memTemplParams" colspan="2">template<class T_arg1 > </td></tr>
+<tr class="memitem:ad5f69b862958bf7c45e7f6d3bc5f4c6e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1adaptor__functor.html#ad5f69b862958bf7c45e7f6d3bc5f4c6e">operator()</a> (T_arg1 _A_arg1) const</td></tr>
+<tr class="memdesc:ad5f69b862958bf7c45e7f6d3bc5f4c6e"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="structsigc_1_1adaptor__functor.html#ad5f69b862958bf7c45e7f6d3bc5f4c6e">More...</a><br /></td></tr>
+<tr class="separator:ad5f69b862958bf7c45e7f6d3bc5f4c6e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aab920cf1b05ce5d6c9513aa18323ea2a"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:aab920cf1b05ce5d6c9513aa18323ea2a"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1adaptor__functor.html#aab920cf1b05ce5d6c9513aa18323ea2a">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2) const</td></tr>
+<tr class="memdesc:aab920cf1b05ce5d6c9513aa18323ea2a"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="structsigc_1_1adaptor__functor.html#aab920cf1b05ce5d6c9513aa18323ea2a">More...</a><br /></td></tr>
+<tr class="separator:aab920cf1b05ce5d6c9513aa18323ea2a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0da9456dab8a22caffe6cfd624e32e30"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:a0da9456dab8a22caffe6cfd624e32e30"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1adaptor__functor.html#a0da9456dab8a22caffe6cfd624e32e30">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3) const</td></tr>
+<tr class="memdesc:a0da9456dab8a22caffe6cfd624e32e30"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="structsigc_1_1adaptor__functor.html#a0da9456dab8a22caffe6cfd624e32e30">More...</a><br /></td></tr>
+<tr class="separator:a0da9456dab8a22caffe6cfd624e32e30"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2b393cd9388414a1a6ad7148eec4354a"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:a2b393cd9388414a1a6ad7148eec4354a"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1adaptor__functor.html#a2b393cd9388414a1a6ad7148eec4354a">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4) const</td></tr>
+<tr class="memdesc:a2b393cd9388414a1a6ad7148eec4354a"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="structsigc_1_1adaptor__functor.html#a2b393cd9388414a1a6ad7148eec4354a">More...</a><br /></td></tr>
+<tr class="separator:a2b393cd9388414a1a6ad7148eec4354a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9bec9cfe2f00505a35cdb2b8d5117b09"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:a9bec9cfe2f00505a35cdb2b8d5117b09"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1adaptor__functor.html#a9bec9cfe2f00505a35cdb2b8d5117b09">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5) const</td></tr>
+<tr class="memdesc:a9bec9cfe2f00505a35cdb2b8d5117b09"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="structsigc_1_1adaptor__functor.html#a9bec9cfe2f00505a35cdb2b8d5117b09">More...</a><br /></td></tr>
+<tr class="separator:a9bec9cfe2f00505a35cdb2b8d5117b09"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a824de5f3164f45f78ea3771743b94ca4"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:a824de5f3164f45f78ea3771743b94ca4"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1adaptor__functor.html#a824de5f3164f45f78ea3771743b94ca4">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6) const</td></tr>
+<tr class="memdesc:a824de5f3164f45f78ea3771743b94ca4"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="structsigc_1_1adaptor__functor.html#a824de5f3164f45f78ea3771743b94ca4">More...</a><br /></td></tr>
+<tr class="separator:a824de5f3164f45f78ea3771743b94ca4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5be4edc8ea900c6454cb024836b9f655"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:a5be4edc8ea900c6454cb024836b9f655"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1adaptor__functor.html#a5be4edc8ea900c6454cb024836b9f655">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6, T_arg7 _A_arg7) const</td></tr>
+<tr class="memdesc:a5be4edc8ea900c6454cb024836b9f655"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="structsigc_1_1adaptor__functor.html#a5be4edc8ea900c6454cb024836b9f655">More...</a><br /></td></tr>
+<tr class="separator:a5be4edc8ea900c6454cb024836b9f655"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:a4faff6b7a82f4f6d92e3d3b0aa8fdca8"><td class="memItemLeft" align="right" valign="top">T_functor </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adaptor__functor.html#a4faff6b7a82f4f6d92e3d3b0aa8fdca8">functor_</a></td></tr>
+<tr class="memdesc:a4faff6b7a82f4f6d92e3d3b0aa8fdca8"><td class="mdescLeft"> </td><td class="mdescRight">Functor that is invoked from <a class="el" href="structsigc_1_1adaptor__functor.html#aa8f3859324cce86596f0eb81b7bb6037" title="Invokes the wrapped functor passing on the arguments.">operator()()</a>. <a href="structsigc_1_1adaptor__functor.html#a4faff6b7a82f4f6d92e3d3b0aa8fdca8">More...</a><br /></td></tr>
+<tr class="separator:a4faff6b7a82f4f6d92e3d3b0aa8fdca8"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_functor><br />
+struct sigc::adaptor_functor< T_functor ></h3>
+
+<p>Converts an arbitrary functor into an adaptor type. </p>
+<p>All adaptor types in libsigc++ have a <code>template operator()</code> member of every argument count they support. These functions in turn invoke a stored adaptor's <code>template operator()</code>, processing the arguments and return value in a characteristic manner. Explicit function template instantiation is used to pass type hints thus saving copy costs.</p>
+<p><a class="el" href="structsigc_1_1adaptor__functor.html" title="Converts an arbitrary functor into an adaptor type.">adaptor_functor</a> is a glue between adaptors and arbitrary functors that just passes on the arguments. You won't use this type directly.</p>
+<p>The template argument <em>T_functor</em> determines the type of stored functor. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="adc1e7ebba9db294494c62666e10b719b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#adc1e7ebba9db294494c62666e10b719b">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1functor__trait.html">functor_trait</a><T_functor>::<a class="el" href="structsigc_1_1adaptor__functor.html#adc1e7ebba9db294494c62666e10b719b">result_type</a> <a class="el" href="structsigc_1_1adaptor__functor.html">sigc::adaptor_functor</a>< T_functor >::<a class="el" href="structsigc_1_1adaptor__functor.html#adc1e7ebba9db294494c62666e10b719b">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a39ef4610f8e0f03425b6f4a44b59e5fb"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a39ef4610f8e0f03425b6f4a44b59e5fb">◆ </a></span>adaptor_functor() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1adaptor__functor.html">sigc::adaptor_functor</a>< T_functor >::<a class="el" href="structsigc_1_1adaptor__functor.html">adaptor_functor</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an invalid functor. </p>
+
+</div>
+</div>
+<a id="ac5907212f7ee2eadf10b31757a0c5930"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac5907212f7ee2eadf10b31757a0c5930">◆ </a></span>adaptor_functor() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1adaptor__functor.html">sigc::adaptor_functor</a>< T_functor >::<a class="el" href="structsigc_1_1adaptor__functor.html">adaptor_functor</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an <a class="el" href="structsigc_1_1adaptor__functor.html" title="Converts an arbitrary functor into an adaptor type.">adaptor_functor</a> object that wraps the passed functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor to invoke from <a class="el" href="structsigc_1_1adaptor__functor.html#aa8f3859324cce86596f0eb81b7bb6037" title="Invokes the wrapped functor passing on the arguments.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="af765e401002eb15f18aca5cfaa678b01"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af765e401002eb15f18aca5cfaa678b01">◆ </a></span>adaptor_functor() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_type > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1adaptor__functor.html">sigc::adaptor_functor</a>< T_functor >::<a class="el" href="structsigc_1_1adaptor__functor.html">adaptor_functor</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_type & </td>
+ <td class="paramname"><em>_A_type</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an <a class="el" href="structsigc_1_1adaptor__functor.html" title="Converts an arbitrary functor into an adaptor type.">adaptor_functor</a> object that wraps the passed (member) function pointer. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_type</td><td>Pointer to function or class method to invoke from <a class="el" href="structsigc_1_1adaptor__functor.html#aa8f3859324cce86596f0eb81b7bb6037" title="Invokes the wrapped functor passing on the arguments.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="aa8f3859324cce86596f0eb81b7bb6037"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa8f3859324cce86596f0eb81b7bb6037">◆ </a></span>operator()() <span class="overload">[1/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1adaptor__functor.html">adaptor_functor</a>< T_functor >::<a class="el" href="structsigc_1_1adaptor__functor.html#adc1e7ebba9db294494c62666e10b719b">result_type</a> <a class="el" href="structsigc_1_1adaptor__functor.html">sigc::adaptor_functor</a>< T_functor >::operator()</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="ad5f69b862958bf7c45e7f6d3bc5f4c6e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad5f69b862958bf7c45e7f6d3bc5f4c6e">◆ </a></span>operator()() <span class="overload">[2/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1>::type <a class="el" href="structsigc_1_1adaptor__functor.html">sigc::adaptor_functor</a>< T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_arg1</em></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_arg1</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="aab920cf1b05ce5d6c9513aa18323ea2a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aab920cf1b05ce5d6c9513aa18323ea2a">◆ </a></span>operator()() <span class="overload">[3/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2>::type <a class="el" href="structsigc_1_1adaptor__functor.html">sigc::adaptor_functor</a>< T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_arg1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_arg2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_arg1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg2</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a0da9456dab8a22caffe6cfd624e32e30"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0da9456dab8a22caffe6cfd624e32e30">◆ </a></span>operator()() <span class="overload">[4/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3>::type <a class="el" href="structsigc_1_1adaptor__functor.html">sigc::adaptor_functor</a>< T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_arg1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_arg2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_arg3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_arg1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg3</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a2b393cd9388414a1a6ad7148eec4354a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2b393cd9388414a1a6ad7148eec4354a">◆ </a></span>operator()() <span class="overload">[5/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4>::type <a class="el" href="structsigc_1_1adaptor__functor.html">sigc::adaptor_functor</a>< T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_arg1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_arg2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_arg3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_arg4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_arg1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg4</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a9bec9cfe2f00505a35cdb2b8d5117b09"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9bec9cfe2f00505a35cdb2b8d5117b09">◆ </a></span>operator()() <span class="overload">[6/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type <a class="el" href="structsigc_1_1adaptor__functor.html">sigc::adaptor_functor</a>< T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_arg1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_arg2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_arg3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_arg4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_arg5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_arg1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg4</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg5</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a824de5f3164f45f78ea3771743b94ca4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a824de5f3164f45f78ea3771743b94ca4">◆ </a></span>operator()() <span class="overload">[7/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type <a class="el" href="structsigc_1_1adaptor__functor.html">sigc::adaptor_functor</a>< T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_arg1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_arg2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_arg3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_arg4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_arg5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg6 </td>
+ <td class="paramname"><em>_A_arg6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_arg1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg4</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg5</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg6</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a5be4edc8ea900c6454cb024836b9f655"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5be4edc8ea900c6454cb024836b9f655">◆ </a></span>operator()() <span class="overload">[8/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type <a class="el" href="structsigc_1_1adaptor__functor.html">sigc::adaptor_functor</a>< T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_arg1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_arg2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_arg3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_arg4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_arg5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg6 </td>
+ <td class="paramname"><em>_A_arg6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg7 </td>
+ <td class="paramname"><em>_A_arg7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_arg1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg4</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg5</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg6</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg7</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a4faff6b7a82f4f6d92e3d3b0aa8fdca8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4faff6b7a82f4f6d92e3d3b0aa8fdca8">◆ </a></span>functor_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_functor <a class="el" href="structsigc_1_1adaptor__functor.html">sigc::adaptor_functor</a>< T_functor >::functor_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">mutable</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Functor that is invoked from <a class="el" href="structsigc_1_1adaptor__functor.html#aa8f3859324cce86596f0eb81b7bb6037" title="Invokes the wrapped functor passing on the arguments.">operator()()</a>. </p>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::adaptor_functor< T_functor >" name="sigc::adaptor_functor< T_functor >">
+<area shape="rect" id="node1" title="Converts an arbitrary functor into an adaptor type." alt="" coords="5,155,164,196"/>
+<area shape="rect" id="node2" href="$structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="13,80,157,107"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="15,5,155,32"/>
+</map>
--- /dev/null
+3d90f5f99eb6cec21c8a61789b4e0560
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::adaptor_trait< T_functor, I_isadaptor > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::adaptor_trait< T_functor, I_isadaptor > Struct Template Reference<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Trait that specifies what is the adaptor version of a functor type.
+ <a href="structsigc_1_1adaptor__trait.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/adaptor_trait.h></code></p>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_functor, bool I_isadaptor = std::is_base_of<adaptor_base, T_functor>::value><br />
+struct sigc::adaptor_trait< T_functor, I_isadaptor ></h3>
+
+<p>Trait that specifies what is the adaptor version of a functor type. </p>
+<p>Template specializations for <a class="el" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler.">sigc::adaptor_base</a> derived functors, for function pointers and for class methods are provided.</p>
+<p>The template argument <em>T_functor</em> is the functor type to convert. <em>I_isadaptor</em> indicates whether <em>T_functor</em> inherits from <a class="el" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler.">sigc::adaptor_base</a>. </p>
+</div></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html">adaptor_trait< T_functor, false ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::adaptor_trait< T_functor, false > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html">sigc::adaptor_trait< T_functor, false ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html#ad3bd68364a24b2b6580b523d5301b25c">adaptor_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html">sigc::adaptor_trait< T_functor, false ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html#acb1a7066d665d00e2525c49d089efc0f">functor_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html">sigc::adaptor_trait< T_functor, false ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html#a512a6d201bdd43574a2df993b3b85d0e">result_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html">sigc::adaptor_trait< T_functor, false ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::adaptor_trait< T_functor, false > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html">adaptor_trait< T_functor, false ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::adaptor_trait< T_functor, false > Struct Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Trait that specifies what is the adaptor version of a functor type.
+ <a href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/adaptor_trait.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:ad3bd68364a24b2b6580b523d5301b25c"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__functor.html">adaptor_functor</a>< <a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html#acb1a7066d665d00e2525c49d089efc0f">functor_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html#ad3bd68364a24b2b6580b523d5301b25c">adaptor_type</a></td></tr>
+<tr class="separator:ad3bd68364a24b2b6580b523d5301b25c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acb1a7066d665d00e2525c49d089efc0f"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1functor__trait.html">functor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html#acb1a7066d665d00e2525c49d089efc0f">functor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html#acb1a7066d665d00e2525c49d089efc0f">functor_type</a></td></tr>
+<tr class="separator:acb1a7066d665d00e2525c49d089efc0f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a512a6d201bdd43574a2df993b3b85d0e"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1functor__trait.html">functor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html#a512a6d201bdd43574a2df993b3b85d0e">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html#a512a6d201bdd43574a2df993b3b85d0e">result_type</a></td></tr>
+<tr class="separator:a512a6d201bdd43574a2df993b3b85d0e"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_functor><br />
+struct sigc::adaptor_trait< T_functor, false ></h3>
+
+<p>Trait that specifies what is the adaptor version of a functor type. </p>
+<p>This template specialization is used for arbitrary functors, for function pointers and for class methods are provided. The latter are converted into <code>pointer_functor</code> or <code>mem_functor</code> types. adaptor_type is equal to <code>adaptor_functor<functor_type></code>. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="ad3bd68364a24b2b6580b523d5301b25c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad3bd68364a24b2b6580b523d5301b25c">◆ </a></span>adaptor_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1adaptor__functor.html">adaptor_functor</a><<a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html#acb1a7066d665d00e2525c49d089efc0f">functor_type</a>> <a class="el" href="structsigc_1_1adaptor__trait.html">sigc::adaptor_trait</a>< T_functor, false >::<a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html#ad3bd68364a24b2b6580b523d5301b25c">adaptor_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="acb1a7066d665d00e2525c49d089efc0f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#acb1a7066d665d00e2525c49d089efc0f">◆ </a></span>functor_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1functor__trait.html">functor_trait</a><T_functor>::<a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html#acb1a7066d665d00e2525c49d089efc0f">functor_type</a> <a class="el" href="structsigc_1_1adaptor__trait.html">sigc::adaptor_trait</a>< T_functor, false >::<a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html#acb1a7066d665d00e2525c49d089efc0f">functor_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a512a6d201bdd43574a2df993b3b85d0e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a512a6d201bdd43574a2df993b3b85d0e">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1functor__trait.html">functor_trait</a><T_functor>::<a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html#a512a6d201bdd43574a2df993b3b85d0e">result_type</a> <a class="el" href="structsigc_1_1adaptor__trait.html">sigc::adaptor_trait</a>< T_functor, false >::<a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html#a512a6d201bdd43574a2df993b3b85d0e">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html">adaptor_trait< T_functor, true ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::adaptor_trait< T_functor, true > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html">sigc::adaptor_trait< T_functor, true ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html#a449daad4cd77bd1fbfe59d8fae9d9039">adaptor_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html">sigc::adaptor_trait< T_functor, true ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html#ae065e339af2abe58cad43d630328240f">functor_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html">sigc::adaptor_trait< T_functor, true ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html#a6b83ed91f53a25e7002546a2835457b3">result_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html">sigc::adaptor_trait< T_functor, true ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::adaptor_trait< T_functor, true > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html">adaptor_trait< T_functor, true ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::adaptor_trait< T_functor, true > Struct Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Trait that specifies what is the adaptor version of a functor type.
+ <a href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/adaptor_trait.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a449daad4cd77bd1fbfe59d8fae9d9039"><td class="memItemLeft" align="right" valign="top">typedef T_functor </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html#a449daad4cd77bd1fbfe59d8fae9d9039">adaptor_type</a></td></tr>
+<tr class="separator:a449daad4cd77bd1fbfe59d8fae9d9039"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae065e339af2abe58cad43d630328240f"><td class="memItemLeft" align="right" valign="top">typedef T_functor </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html#ae065e339af2abe58cad43d630328240f">functor_type</a></td></tr>
+<tr class="separator:ae065e339af2abe58cad43d630328240f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a6b83ed91f53a25e7002546a2835457b3"><td class="memItemLeft" align="right" valign="top">typedef T_functor::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html#a6b83ed91f53a25e7002546a2835457b3">result_type</a></td></tr>
+<tr class="separator:a6b83ed91f53a25e7002546a2835457b3"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_functor><br />
+struct sigc::adaptor_trait< T_functor, true ></h3>
+
+<p>Trait that specifies what is the adaptor version of a functor type. </p>
+<p>This template specialization is used for types that inherit from <a class="el" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler.">adaptor_base</a>. adaptor_type is equal to <code>T_functor</code> in this case. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a449daad4cd77bd1fbfe59d8fae9d9039"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a449daad4cd77bd1fbfe59d8fae9d9039">◆ </a></span>adaptor_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_functor <a class="el" href="structsigc_1_1adaptor__trait.html">sigc::adaptor_trait</a>< T_functor, true >::<a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html#a449daad4cd77bd1fbfe59d8fae9d9039">adaptor_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ae065e339af2abe58cad43d630328240f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae065e339af2abe58cad43d630328240f">◆ </a></span>functor_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_functor <a class="el" href="structsigc_1_1adaptor__trait.html">sigc::adaptor_trait</a>< T_functor, true >::<a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html#ae065e339af2abe58cad43d630328240f">functor_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a6b83ed91f53a25e7002546a2835457b3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a6b83ed91f53a25e7002546a2835457b3">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_functor::result_type <a class="el" href="structsigc_1_1adaptor__trait.html">sigc::adaptor_trait</a>< T_functor, true >::<a class="el" href="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html#a6b83ed91f53a25e7002546a2835457b3">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1adapts.html">adapts</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::adapts< T_functor > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a>(const T_functor & _A_functor)</td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::adapts< T_functor > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1adapts.html">adapts</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="structsigc_1_1adapts-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::adapts< T_functor > Struct Template Reference<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Base type for adaptors.
+ <a href="structsigc_1_1adapts.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/adaptor_trait.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::adapts< T_functor >:</div>
+<div class="dyncontent">
+<div class="center"><img src="structsigc_1_1adapts__inherit__graph.png" border="0" usemap="#asigc_1_1adapts_3_01T__functor_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1adapts_3_01T__functor_01_4_inherit__map" id="asigc_1_1adapts_3_01T__functor_01_4_inherit__map">
+<area shape="rect" title="Base type for adaptors." alt="" coords="385,400,576,427"/>
+<area shape="rect" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Adaptor that binds an argument to the wrapped functor." alt="" coords="640,5,821,61"/>
+<area shape="rect" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Adaptor that binds 1 argument(s) to the wrapped functor." alt="" coords="641,85,820,141"/>
+<area shape="rect" href="structsigc_1_1bind__return__functor.html" title="Adaptor that fixes the return value of the wrapped functor." alt="" coords="639,166,822,207"/>
+<area shape="rect" href="structsigc_1_1exception__catch__functor.html" title=" " alt="" coords="647,232,814,288"/>
+<area shape="rect" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html" title=" " alt="" coords="649,312,812,368"/>
+<area shape="rect" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html" title="Adaptor that adds a dummy parameter to the wrapped functor." alt="" coords="662,393,799,434"/>
+<area shape="rect" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html" title="Adaptor that adds a dummy parameter to the wrapped functor." alt="" coords="662,458,799,499"/>
+<area shape="rect" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor." alt="" coords="624,523,837,594"/>
+<area shape="rect" href="structsigc_1_1retype__return__functor.html" title="Adaptor that performs a C-style cast on the return value of a functor." alt="" coords="657,619,805,675"/>
+<area shape="rect" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html" title="Adaptor that performs a C-style cast on the return value of a functor." alt="" coords="629,699,832,741"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object." alt="" coords="642,765,819,806"/>
+<area shape="rect" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="193,400,337,427"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,400,145,427"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor2.html" title="track_obj_functor2 wraps a functor and stores 2 references to trackable objects." alt="" coords="891,571,1105,613"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor3.html" title="track_obj_functor3 wraps a functor and stores 3 references to trackable objects." alt="" coords="909,637,1087,693"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor4.html" title="track_obj_functor4 wraps a functor and stores 4 references to trackable objects." alt="" coords="909,717,1087,773"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor5.html" title="track_obj_functor5 wraps a functor and stores 5 references to trackable objects." alt="" coords="885,797,1111,853"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor6.html" title="track_obj_functor6 wraps a functor and stores 6 references to trackable objects." alt="" coords="909,878,1087,949"/>
+<area shape="rect" href="classsigc_1_1track__obj__functor7.html" title="track_obj_functor7 wraps a functor and stores 7 references to trackable objects." alt="" coords="909,973,1087,1043"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a5c3f3b614455552f4cd5d88b1f330248"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td></tr>
+<tr class="separator:a5c3f3b614455552f4cd5d88b1f330248"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a914e75556dae1fdcf0162c4c99aca79d"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td></tr>
+<tr class="separator:a914e75556dae1fdcf0162c4c99aca79d"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a947b69ccbdcabd4ef4163dcab96096f8"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a> (const T_functor & _A_functor)</td></tr>
+<tr class="memdesc:a947b69ccbdcabd4ef4163dcab96096f8"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an adaptor that wraps the passed functor. <a href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">More...</a><br /></td></tr>
+<tr class="separator:a947b69ccbdcabd4ef4163dcab96096f8"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:a2f4b37eb160708baf17de57f2abce7a7"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td></tr>
+<tr class="memdesc:a2f4b37eb160708baf17de57f2abce7a7"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that is invoked from operator()(). <a href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">More...</a><br /></td></tr>
+<tr class="separator:a2f4b37eb160708baf17de57f2abce7a7"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_functor><br />
+struct sigc::adapts< T_functor ></h3>
+
+<p>Base type for adaptors. </p>
+<p><a class="el" href="structsigc_1_1adapts.html" title="Base type for adaptors.">sigc::adapts</a> wraps adaptors, functors, function pointers and class methods. It contains a single member functor which is always a <a class="el" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler.">sigc::adaptor_base</a>. 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 <em>T_functor</em> unless <em>T_functor</em> inherits from <a class="el" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler.">sigc::adaptor_base</a>.</p>
+<dl class="section user"><dt>Example of a simple adaptor:</dt><dd><div class="fragment"><div class="line"><span class="keyword">namespace </span>my_ns</div>
+<div class="line">{</div>
+<div class="line"><span class="keyword">template</span> <<span class="keyword">class</span> T_functor></div>
+<div class="line"><span class="keyword">struct </span>my_adaptor : <span class="keyword">public</span> <a class="code" href="structsigc_1_1adapts.html">sigc::adapts</a><T_functor></div>
+<div class="line">{</div>
+<div class="line"> <span class="keyword">template</span> <<span class="keyword">class</span> T_arg1=<span class="keywordtype">void</span>, <span class="keyword">class</span> T_arg2=<span class="keywordtype">void</span>></div>
+<div class="line"> <span class="keyword">struct </span>deduce_result_type</div>
+<div class="line"> { <span class="keyword">typedef</span> <a class="code" href="namespacesigc.html#ab7791439fb79592300826fe076a8e3d1">sigc::deduce_result_t<T_functor, T_arg1, T_arg2></a> type; };</div>
+<div class="line"> <span class="keyword">typedef</span> <span class="keyword">typename</span> <a class="code" href="structsigc_1_1functor__trait.html#af1324bf0d3cec3d1f2e39e932b228d6d">sigc::functor_trait<T_functor>::result_type</a> <a class="code" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a>;</div>
+<div class="line"> <span class="comment">//</span></div>
+<div class="line"> <a class="code" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></div>
+<div class="line"> operator()() <span class="keyword">const</span>;</div>
+<div class="line"> <span class="comment">//</span></div>
+<div class="line"> <span class="keyword">template</span> <<span class="keyword">class</span> T_arg1></div>
+<div class="line"> <span class="keyword">typename</span> <a class="code" href="structsigc_1_1deduce__result__type.html#a529a6b7809ea3ad1a2d4392b9ffcec42">deduce_result_type<T_arg1>::type</a></div>
+<div class="line"> operator()(T_arg1 _A_arg1) <span class="keyword">const</span>;</div>
+<div class="line"> <span class="comment">//</span></div>
+<div class="line"> <span class="keyword">template</span> <<span class="keyword">class</span> T_arg1, <span class="keyword">class</span> T_arg2></div>
+<div class="line"> <span class="keyword">typename</span> <a class="code" href="structsigc_1_1deduce__result__type.html#a529a6b7809ea3ad1a2d4392b9ffcec42">deduce_result_type<T_arg1, T_arg2>::type</a></div>
+<div class="line"> operator()(T_arg1 _A_arg1, T_arg2 _A_arg2) <span class="keyword">const</span>;</div>
+<div class="line"> <span class="comment">//</span></div>
+<div class="line"> <span class="comment">// Constructs a my_adaptor object that wraps the passed functor.</span></div>
+<div class="line"> <span class="comment">// Initializes adapts<T_functor>::functor_, which is invoked from operator()().</span></div>
+<div class="line"> <span class="keyword">explicit</span> my_adaptor(<span class="keyword">const</span> T_functor& _A_functor)</div>
+<div class="line"> : <a class="code" href="namespacesigc.html">sigc</a>::<a class="code" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a><T_functor>(_A_functor) {}</div>
+<div class="line">};</div>
+<div class="line">} <span class="comment">// end namespace my_ns</span></div>
+<div class="line"><span class="comment">//</span></div>
+<div class="line"><span class="comment">// Specialization of sigc::visitor for my_adaptor.</span></div>
+<div class="line"><span class="keyword">namespace </span><a class="code" href="namespacesigc.html">sigc</a></div>
+<div class="line">{</div>
+<div class="line"><span class="keyword">template</span> <<span class="keyword">class</span> T_functor></div>
+<div class="line"><span class="keyword">struct </span>visitor<my_ns::my_adaptor<T_functor> ></div>
+<div class="line">{</div>
+<div class="line"> <span class="keyword">template</span> <<span class="keyword">class</span> T_action></div>
+<div class="line"> <span class="keyword">static</span> <span class="keywordtype">void</span> do_visit_each(<span class="keyword">const</span> T_action& _A_action,</div>
+<div class="line"> <span class="keyword">const</span> my_ns::my_adaptor<T_functor>& _A_target)</div>
+<div class="line"> {</div>
+<div class="line"> <a class="code" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404">sigc::visit_each</a>(_A_action, _A_target.functor_);</div>
+<div class="line"> }</div>
+<div class="line">};</div>
+<div class="line">} <span class="comment">// end namespace sigc</span></div>
+<div class="ttc" id="agroup__sigcfunctors_html_ga64cb7832acc1e58efb5ffe0b4f5e9404"><div class="ttname"><a href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404">sigc::visit_each</a></div><div class="ttdeci">void visit_each(const T_action &_A_action, const T_functor &_A_functor)</div><div class="ttdoc">This function performs a functor on each of the targets of a functor.</div><div class="ttdef"><b>Definition:</b> visit_each.h:169</div></div>
+<div class="ttc" id="anamespacesigc_html"><div class="ttname"><a href="namespacesigc.html">sigc</a></div><div class="ttdoc">The libsigc++ namespace.</div><div class="ttdef"><b>Definition:</b> limit_reference.h:12</div></div>
+<div class="ttc" id="anamespacesigc_html_ab7791439fb79592300826fe076a8e3d1"><div class="ttname"><a href="namespacesigc.html#ab7791439fb79592300826fe076a8e3d1">sigc::deduce_result_t</a></div><div class="ttdeci">typename deduce_result_type< T_functor, T_args... >::type deduce_result_t</div><div class="ttdef"><b>Definition:</b> deduce_result_type.h:68</div></div>
+<div class="ttc" id="astructsigc_1_1adapts_html"><div class="ttname"><a href="structsigc_1_1adapts.html">sigc::adapts</a></div><div class="ttdoc">Base type for adaptors.</div><div class="ttdef"><b>Definition:</b> adaptor_trait.h:387</div></div>
+<div class="ttc" id="astructsigc_1_1adapts_html_a914e75556dae1fdcf0162c4c99aca79d"><div class="ttname"><a href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">sigc::adapts::result_type</a></div><div class="ttdeci">adaptor_trait< T_functor >::result_type result_type</div><div class="ttdef"><b>Definition:</b> adaptor_trait.h:388</div></div>
+<div class="ttc" id="astructsigc_1_1adapts_html_a947b69ccbdcabd4ef4163dcab96096f8"><div class="ttname"><a href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">sigc::adapts::adapts</a></div><div class="ttdeci">adapts(const T_functor &_A_functor)</div><div class="ttdoc">Constructs an adaptor that wraps the passed functor.</div><div class="ttdef"><b>Definition:</b> adaptor_trait.h:394</div></div>
+<div class="ttc" id="astructsigc_1_1deduce__result__type_html_a529a6b7809ea3ad1a2d4392b9ffcec42"><div class="ttname"><a href="structsigc_1_1deduce__result__type.html#a529a6b7809ea3ad1a2d4392b9ffcec42">sigc::deduce_result_type::type</a></div><div class="ttdeci">decltype(test< T_functor >()) type</div><div class="ttdef"><b>Definition:</b> deduce_result_type.h:64</div></div>
+<div class="ttc" id="astructsigc_1_1functor__trait_html_af1324bf0d3cec3d1f2e39e932b228d6d"><div class="ttname"><a href="structsigc_1_1functor__trait.html#af1324bf0d3cec3d1f2e39e932b228d6d">sigc::functor_trait::result_type</a></div><div class="ttdeci">void result_type</div><div class="ttdef"><b>Definition:</b> functor_trait.h:135</div></div>
+</div><!-- fragment --></dd></dl>
+<p>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 <a class="el" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection.">sigc::trackable</a> object is destroyed and you can end up executing callbacks on destroyed objects.</p>
+<p>Your specialization of sigc::visitor<> must be in namespace sigc. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a5c3f3b614455552f4cd5d88b1f330248"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5c3f3b614455552f4cd5d88b1f330248">◆ </a></span>adaptor_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a><T_functor>::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> <a class="el" href="structsigc_1_1adapts.html">sigc::adapts</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a914e75556dae1fdcf0162c4c99aca79d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a914e75556dae1fdcf0162c4c99aca79d">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a><T_functor>::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> <a class="el" href="structsigc_1_1adapts.html">sigc::adapts</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a947b69ccbdcabd4ef4163dcab96096f8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a947b69ccbdcabd4ef4163dcab96096f8">◆ </a></span>adapts()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html">adapts</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an adaptor that wraps the passed functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor to invoke from operator()(). </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a2f4b37eb160708baf17de57f2abce7a7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2f4b37eb160708baf17de57f2abce7a7">◆ </a></span>functor_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> <a class="el" href="structsigc_1_1adapts.html">sigc::adapts</a>< T_functor >::functor_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">mutable</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Adaptor that is invoked from operator()(). </p>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::adapts< T_functor >" name="sigc::adapts< T_functor >">
+<area shape="rect" id="node1" title="Base type for adaptors." alt="" coords="385,400,576,427"/>
+<area shape="rect" id="node4" href="$structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Adaptor that binds an argument to the wrapped functor." alt="" coords="640,5,821,61"/>
+<area shape="rect" id="node5" href="$structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Adaptor that binds 1 argument(s) to the wrapped functor." alt="" coords="641,85,820,141"/>
+<area shape="rect" id="node6" href="$structsigc_1_1bind__return__functor.html" title="Adaptor that fixes the return value of the wrapped functor." alt="" coords="639,166,822,207"/>
+<area shape="rect" id="node7" href="$structsigc_1_1exception__catch__functor.html" title=" " alt="" coords="647,232,814,288"/>
+<area shape="rect" id="node8" href="$structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html" title=" " alt="" coords="649,312,812,368"/>
+<area shape="rect" id="node9" href="$structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html" title="Adaptor that adds a dummy parameter to the wrapped functor." alt="" coords="662,393,799,434"/>
+<area shape="rect" id="node10" href="$structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html" title="Adaptor that adds a dummy parameter to the wrapped functor." alt="" coords="662,458,799,499"/>
+<area shape="rect" id="node11" href="$structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor." alt="" coords="624,523,837,594"/>
+<area shape="rect" id="node12" href="$structsigc_1_1retype__return__functor.html" title="Adaptor that performs a C-style cast on the return value of a functor." alt="" coords="657,619,805,675"/>
+<area shape="rect" id="node13" href="$structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html" title="Adaptor that performs a C-style cast on the return value of a functor." alt="" coords="629,699,832,741"/>
+<area shape="rect" id="node14" href="$classsigc_1_1track__obj__functor1.html" title="track_obj_functor1 wraps a functor and stores a reference to a trackable object." alt="" coords="642,765,819,806"/>
+<area shape="rect" id="node2" href="$structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="193,400,337,427"/>
+<area shape="rect" id="node3" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="5,400,145,427"/>
+<area shape="rect" id="node15" href="$classsigc_1_1track__obj__functor2.html" title="track_obj_functor2 wraps a functor and stores 2 references to trackable objects." alt="" coords="891,571,1105,613"/>
+<area shape="rect" id="node16" href="$classsigc_1_1track__obj__functor3.html" title="track_obj_functor3 wraps a functor and stores 3 references to trackable objects." alt="" coords="909,637,1087,693"/>
+<area shape="rect" id="node17" href="$classsigc_1_1track__obj__functor4.html" title="track_obj_functor4 wraps a functor and stores 4 references to trackable objects." alt="" coords="909,717,1087,773"/>
+<area shape="rect" id="node18" href="$classsigc_1_1track__obj__functor5.html" title="track_obj_functor5 wraps a functor and stores 5 references to trackable objects." alt="" coords="885,797,1111,853"/>
+<area shape="rect" id="node19" href="$classsigc_1_1track__obj__functor6.html" title="track_obj_functor6 wraps a functor and stores 6 references to trackable objects." alt="" coords="909,878,1087,949"/>
+<area shape="rect" id="node20" href="$classsigc_1_1track__obj__functor7.html" title="track_obj_functor7 wraps a functor and stores 7 references to trackable objects." alt="" coords="909,973,1087,1043"/>
+</map>
--- /dev/null
+80bfb6b4fc08fe51ab10bf37c979641c
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bind_functor< I_location, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bind_functor< I_location, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 > Struct Template Reference<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a> » <a class="el" href="group__bind.html">bind(), bind_return()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Adaptor that binds an argument to the wrapped functor.
+ <a href="structsigc_1_1bind__functor.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/bind.h></code></p>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<int I_location, class T_functor, class T_type1 = nil, class T_type2 = nil, class T_type3 = nil, class T_type4 = nil, class T_type5 = nil, class T_type6 = nil, class T_type7 = nil><br />
+struct sigc::bind_functor< I_location, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 ></h3>
+
+<p>Adaptor that binds an argument to the wrapped functor. </p>
+<p>Use the convenience function <a class="el" href="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" title="Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.">sigc::bind()</a> to create an instance of <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">sigc::bind_functor</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>I_location</em> Zero-based position of the argument to fix (<code>-1</code> for the last argument).</li>
+<li><em>T_type1</em> Type of the 1st bound argument.</li>
+<li><em>T_type2</em> Type of the 2nd bound argument.</li>
+<li><em>T_type3</em> Type of the 3rd bound argument.</li>
+<li><em>T_type4</em> Type of the 4th bound argument.</li>
+<li><em>T_type5</em> Type of the 5th bound argument.</li>
+<li><em>T_type6</em> Type of the 6th bound argument.</li>
+<li><em>T_type7</em> Type of the 7th bound argument.</li>
+<li><em>T_functor</em> Type of the functor to wrap. </li>
+</ul>
+</div></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil >" name="sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil >">
+<area shape="rect" id="node1" title="Adaptor that binds 1 argument(s) to the wrapped functor." alt="" coords="11,229,190,285"/>
+<area shape="rect" id="node2" href="$structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="5,155,196,181"/>
+<area shape="rect" id="node3" href="$structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="29,80,173,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="31,5,171,32"/>
+</map>
--- /dev/null
+5a2f46918a0508eb71e66d42d8e27ff7
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ac249b81b5d6fff6e7c4b1d9b47a98077">adaptor_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a>(const T_functor & _A_functor)</td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ad61bb64a42d144999a94767cd6031259">bind_functor</a>(type_trait_take_t< T_functor > _A_func, type_trait_take_t< T_type1 > _A_bound1)</td><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a5e92e05deb3d9e952a49a338bac42cb4">bound1_</a></td><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a5bd5dd13ef2cd495cfd23b8d0f7cffbd">operator()</a>()</td><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a92e97561144280879cce1d04aa8fefa0">operator()</a>(T_arg1 _A_arg1)</td><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a3bdae6371687d34e14925b732361f13f">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2)</td><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a768079067de0ad3fa076eef0bfa5da88">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)</td><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a2f959146fe7ce94745de2b1d10f48a2e">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)</td><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a636774490286342a00251061eb5c550d">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)</td><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a2774a9d3a219ad25326a6490aa4038ae">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)</td><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#abd1e51093bf7d4428e443c2e6704bed9">result_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01ni4ca8293ad07c2413e0de8a15362ea6c4.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil > Struct Template Reference<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a> » <a class="el" href="group__bind.html">bind(), bind_return()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Adaptor that binds 1 argument(s) to the wrapped functor.
+ <a href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/bind.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil >:</div>
+<div class="dyncontent">
+<div class="center"><img src="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01ni35f2e0963b773af799e2db178870d10d.png" border="0" usemap="#asigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map" id="asigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map">
+<area shape="rect" title="Adaptor that binds 1 argument(s) to the wrapped functor." alt="" coords="11,229,190,285"/>
+<area shape="rect" href="structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="5,155,196,181"/>
+<area shape="rect" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="29,80,173,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="31,5,171,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:ac249b81b5d6fff6e7c4b1d9b47a98077"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adapts.html">adapts</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ac249b81b5d6fff6e7c4b1d9b47a98077">adaptor_type</a></td></tr>
+<tr class="separator:ac249b81b5d6fff6e7c4b1d9b47a98077"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abd1e51093bf7d4428e443c2e6704bed9"><td class="memItemLeft" align="right" valign="top">typedef adaptor_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#abd1e51093bf7d4428e443c2e6704bed9">result_type</a></td></tr>
+<tr class="separator:abd1e51093bf7d4428e443c2e6704bed9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td></tr>
+<tr class="separator:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td></tr>
+<tr class="separator:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:ad61bb64a42d144999a94767cd6031259"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ad61bb64a42d144999a94767cd6031259">bind_functor</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_functor > _A_func, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_type1 > _A_bound1)</td></tr>
+<tr class="memdesc:ad61bb64a42d144999a94767cd6031259"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">bind_functor</a> object that binds an argument to the passed functor. <a href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ad61bb64a42d144999a94767cd6031259">More...</a><br /></td></tr>
+<tr class="separator:ad61bb64a42d144999a94767cd6031259"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5bd5dd13ef2cd495cfd23b8d0f7cffbd"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a5bd5dd13ef2cd495cfd23b8d0f7cffbd">operator()</a> ()</td></tr>
+<tr class="memdesc:a5bd5dd13ef2cd495cfd23b8d0f7cffbd"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the bound argument only. <a href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a5bd5dd13ef2cd495cfd23b8d0f7cffbd">More...</a><br /></td></tr>
+<tr class="separator:a5bd5dd13ef2cd495cfd23b8d0f7cffbd"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a92e97561144280879cce1d04aa8fefa0"><td class="memTemplParams" colspan="2">template<class T_arg1 > </td></tr>
+<tr class="memitem:a92e97561144280879cce1d04aa8fefa0"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a92e97561144280879cce1d04aa8fefa0">operator()</a> (T_arg1 _A_arg1)</td></tr>
+<tr class="memdesc:a92e97561144280879cce1d04aa8fefa0"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a92e97561144280879cce1d04aa8fefa0">More...</a><br /></td></tr>
+<tr class="separator:a92e97561144280879cce1d04aa8fefa0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3bdae6371687d34e14925b732361f13f"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:a3bdae6371687d34e14925b732361f13f"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a3bdae6371687d34e14925b732361f13f">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2)</td></tr>
+<tr class="memdesc:a3bdae6371687d34e14925b732361f13f"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a3bdae6371687d34e14925b732361f13f">More...</a><br /></td></tr>
+<tr class="separator:a3bdae6371687d34e14925b732361f13f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a768079067de0ad3fa076eef0bfa5da88"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:a768079067de0ad3fa076eef0bfa5da88"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a768079067de0ad3fa076eef0bfa5da88">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)</td></tr>
+<tr class="memdesc:a768079067de0ad3fa076eef0bfa5da88"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a768079067de0ad3fa076eef0bfa5da88">More...</a><br /></td></tr>
+<tr class="separator:a768079067de0ad3fa076eef0bfa5da88"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2f959146fe7ce94745de2b1d10f48a2e"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:a2f959146fe7ce94745de2b1d10f48a2e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a2f959146fe7ce94745de2b1d10f48a2e">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)</td></tr>
+<tr class="memdesc:a2f959146fe7ce94745de2b1d10f48a2e"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a2f959146fe7ce94745de2b1d10f48a2e">More...</a><br /></td></tr>
+<tr class="separator:a2f959146fe7ce94745de2b1d10f48a2e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a636774490286342a00251061eb5c550d"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:a636774490286342a00251061eb5c550d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a636774490286342a00251061eb5c550d">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)</td></tr>
+<tr class="memdesc:a636774490286342a00251061eb5c550d"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a636774490286342a00251061eb5c550d">More...</a><br /></td></tr>
+<tr class="separator:a636774490286342a00251061eb5c550d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2774a9d3a219ad25326a6490aa4038ae"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:a2774a9d3a219ad25326a6490aa4038ae"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a2774a9d3a219ad25326a6490aa4038ae">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)</td></tr>
+<tr class="memdesc:a2774a9d3a219ad25326a6490aa4038ae"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a2774a9d3a219ad25326a6490aa4038ae">More...</a><br /></td></tr>
+<tr class="separator:a2774a9d3a219ad25326a6490aa4038ae"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a> (const T_functor & _A_functor)</td></tr>
+<tr class="memdesc:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an adaptor that wraps the passed functor. <a href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">More...</a><br /></td></tr>
+<tr class="separator:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:a5e92e05deb3d9e952a49a338bac42cb4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__argument.html">bound_argument</a>< T_type1 > </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a5e92e05deb3d9e952a49a338bac42cb4">bound1_</a></td></tr>
+<tr class="memdesc:a5e92e05deb3d9e952a49a338bac42cb4"><td class="mdescLeft"> </td><td class="mdescRight">The argument bound to the functor. <a href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a5e92e05deb3d9e952a49a338bac42cb4">More...</a><br /></td></tr>
+<tr class="separator:a5e92e05deb3d9e952a49a338bac42cb4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_attribs_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td></tr>
+<tr class="memdesc:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that is invoked from operator()(). <a href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">More...</a><br /></td></tr>
+<tr class="separator:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_functor, class T_type1><br />
+struct sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></h3>
+
+<p>Adaptor that binds 1 argument(s) to the wrapped functor. </p>
+<p>This template specialization fixes the last 1 argument(s) of the wrapped functor. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="ac249b81b5d6fff6e7c4b1d9b47a98077"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac249b81b5d6fff6e7c4b1d9b47a98077">◆ </a></span>adaptor_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_type1 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1adapts.html">adapts</a><T_functor>::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> <a class="el" href="structsigc_1_1bind__functor.html">sigc::bind_functor</a><-1, T_functor, T_type1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="abd1e51093bf7d4428e443c2e6704bed9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abd1e51093bf7d4428e443c2e6704bed9">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_type1 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef adaptor_type::result_type <a class="el" href="structsigc_1_1bind__functor.html">sigc::bind_functor</a><-1, T_functor, T_type1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="ad61bb64a42d144999a94767cd6031259"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad61bb64a42d144999a94767cd6031259">◆ </a></span>bind_functor()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_type1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1bind__functor.html">sigc::bind_functor</a><-1, T_functor, T_type1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_functor > </td>
+ <td class="paramname"><em>_A_func</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_type1 > </td>
+ <td class="paramname"><em>_A_bound1</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">bind_functor</a> object that binds an argument to the passed functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Functor to invoke from <a class="el" href="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a5bd5dd13ef2cd495cfd23b8d0f7cffbd" title="Invokes the wrapped functor passing on the bound argument only.">operator()()</a>. </td></tr>
+ <tr><td class="paramname">_A_bound1</td><td>Argument to bind to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a5bd5dd13ef2cd495cfd23b8d0f7cffbd"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5bd5dd13ef2cd495cfd23b8d0f7cffbd">◆ </a></span>operator()() <span class="overload">[1/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_type1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> <a class="el" href="structsigc_1_1bind__functor.html">sigc::bind_functor</a><-1, T_functor, T_type1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator() </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the bound argument only. </p>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a92e97561144280879cce1d04aa8fefa0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a92e97561144280879cce1d04aa8fefa0">◆ </a></span>operator()() <span class="overload">[2/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_type1 > </div>
+<div class="memtemplate">
+template <class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1>::type <a class="el" href="structsigc_1_1bind__functor.html">sigc::bind_functor</a><-1, T_functor, T_type1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_arg1</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<p>The last 1 argument(s) are fixed. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_arg1</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a3bdae6371687d34e14925b732361f13f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3bdae6371687d34e14925b732361f13f">◆ </a></span>operator()() <span class="overload">[3/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_type1 > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2>::type <a class="el" href="structsigc_1_1bind__functor.html">sigc::bind_functor</a><-1, T_functor, T_type1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_arg1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_arg2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<p>The last 1 argument(s) are fixed. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_arg1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg2</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a768079067de0ad3fa076eef0bfa5da88"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a768079067de0ad3fa076eef0bfa5da88">◆ </a></span>operator()() <span class="overload">[4/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_type1 > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3>::type <a class="el" href="structsigc_1_1bind__functor.html">sigc::bind_functor</a><-1, T_functor, T_type1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_arg1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_arg2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_arg3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<p>The last 1 argument(s) are fixed. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_arg1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg3</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a2f959146fe7ce94745de2b1d10f48a2e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2f959146fe7ce94745de2b1d10f48a2e">◆ </a></span>operator()() <span class="overload">[5/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_type1 > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4>::type <a class="el" href="structsigc_1_1bind__functor.html">sigc::bind_functor</a><-1, T_functor, T_type1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_arg1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_arg2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_arg3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_arg4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<p>The last 1 argument(s) are fixed. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_arg1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg4</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a636774490286342a00251061eb5c550d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a636774490286342a00251061eb5c550d">◆ </a></span>operator()() <span class="overload">[6/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_type1 > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type <a class="el" href="structsigc_1_1bind__functor.html">sigc::bind_functor</a><-1, T_functor, T_type1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_arg1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_arg2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_arg3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_arg4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_arg5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<p>The last 1 argument(s) are fixed. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_arg1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg4</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg5</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a2774a9d3a219ad25326a6490aa4038ae"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2774a9d3a219ad25326a6490aa4038ae">◆ </a></span>operator()() <span class="overload">[7/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_type1 > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type <a class="el" href="structsigc_1_1bind__functor.html">sigc::bind_functor</a><-1, T_functor, T_type1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_arg1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_arg2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_arg3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_arg4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_arg5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg6 </td>
+ <td class="paramname"><em>_A_arg6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<p>The last 1 argument(s) are fixed. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_arg1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg4</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg5</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg6</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a5e92e05deb3d9e952a49a338bac42cb4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5e92e05deb3d9e952a49a338bac42cb4">◆ </a></span>bound1_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_type1 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__argument.html">bound_argument</a><T_type1> <a class="el" href="structsigc_1_1bind__functor.html">sigc::bind_functor</a><-1, T_functor, T_type1, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::bound1_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+<p>The argument bound to the functor. </p>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ac6004db92703257f83addd412037f1f7">adaptor_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a>(const T_functor & _A_functor)</td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ac170bca0fe2af4722cf6e1fd6b3de128">bind_functor</a>(type_trait_take_t< T_functor > _A_func, type_trait_take_t< T_bound > _A_bound)</td><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#afbbf5b4d89cf98a1224da5d72554afdc">bound_</a></td><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a0f1c2891d52c9f564e571209dbef6f54">operator()</a>()</td><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#adf9d663d20ff816a2a4c7d8ffb567eb3">operator()</a>(T_arg1 _A_arg1)</td><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a2f2685399ae595b5e51a3af8c2610481">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2)</td><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a711b443e433977b183c789b175865a1e">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)</td><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a1d0808644eb398cf7036a446b853220d">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)</td><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a8fb31d32467dfe99815ca39b766cafac">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)</td><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a40d96a28bc0a1b7d11e267cc1d7bc517">operator()</a>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)</td><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a1c6d091ffd70c23930cf6e2b9042d466">result_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil >" name="sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil >">
+<area shape="rect" id="node1" title="Adaptor that binds an argument to the wrapped functor." alt="" coords="10,229,191,285"/>
+<area shape="rect" id="node2" href="$structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="5,155,196,181"/>
+<area shape="rect" id="node3" href="$structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="29,80,173,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="31,5,171,32"/>
+</map>
--- /dev/null
+4a8a52637f76ab2a053e633b1e022c89
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_0134a004909681b7eead4388b32fdece62.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil > Struct Template Reference<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a> » <a class="el" href="group__bind.html">bind(), bind_return()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Adaptor that binds an argument to the wrapped functor.
+ <a href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/bind.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil >:</div>
+<div class="dyncontent">
+<div class="center"><img src="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01f6384c348e419c00f69f976bc89ba7b1.png" border="0" usemap="#asigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map" id="asigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_inherit__map">
+<area shape="rect" title="Adaptor that binds an argument to the wrapped functor." alt="" coords="10,229,191,285"/>
+<area shape="rect" href="structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="5,155,196,181"/>
+<area shape="rect" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="29,80,173,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="31,5,171,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:ac6004db92703257f83addd412037f1f7"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adapts.html">adapts</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ac6004db92703257f83addd412037f1f7">adaptor_type</a></td></tr>
+<tr class="separator:ac6004db92703257f83addd412037f1f7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1c6d091ffd70c23930cf6e2b9042d466"><td class="memItemLeft" align="right" valign="top">typedef adaptor_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a1c6d091ffd70c23930cf6e2b9042d466">result_type</a></td></tr>
+<tr class="separator:a1c6d091ffd70c23930cf6e2b9042d466"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td></tr>
+<tr class="separator:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td></tr>
+<tr class="separator:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:ac170bca0fe2af4722cf6e1fd6b3de128"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ac170bca0fe2af4722cf6e1fd6b3de128">bind_functor</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_functor > _A_func, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_bound > _A_bound)</td></tr>
+<tr class="memdesc:ac170bca0fe2af4722cf6e1fd6b3de128"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">bind_functor</a> object that binds an argument to the passed functor. <a href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ac170bca0fe2af4722cf6e1fd6b3de128">More...</a><br /></td></tr>
+<tr class="separator:ac170bca0fe2af4722cf6e1fd6b3de128"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0f1c2891d52c9f564e571209dbef6f54"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a0f1c2891d52c9f564e571209dbef6f54">operator()</a> ()</td></tr>
+<tr class="memdesc:a0f1c2891d52c9f564e571209dbef6f54"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the bound argument only. <a href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a0f1c2891d52c9f564e571209dbef6f54">More...</a><br /></td></tr>
+<tr class="separator:a0f1c2891d52c9f564e571209dbef6f54"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adf9d663d20ff816a2a4c7d8ffb567eb3"><td class="memTemplParams" colspan="2">template<class T_arg1 > </td></tr>
+<tr class="memitem:adf9d663d20ff816a2a4c7d8ffb567eb3"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#adf9d663d20ff816a2a4c7d8ffb567eb3">operator()</a> (T_arg1 _A_arg1)</td></tr>
+<tr class="memdesc:adf9d663d20ff816a2a4c7d8ffb567eb3"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#adf9d663d20ff816a2a4c7d8ffb567eb3">More...</a><br /></td></tr>
+<tr class="separator:adf9d663d20ff816a2a4c7d8ffb567eb3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2f2685399ae595b5e51a3af8c2610481"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:a2f2685399ae595b5e51a3af8c2610481"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a2f2685399ae595b5e51a3af8c2610481">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2)</td></tr>
+<tr class="memdesc:a2f2685399ae595b5e51a3af8c2610481"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a2f2685399ae595b5e51a3af8c2610481">More...</a><br /></td></tr>
+<tr class="separator:a2f2685399ae595b5e51a3af8c2610481"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a711b443e433977b183c789b175865a1e"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:a711b443e433977b183c789b175865a1e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a711b443e433977b183c789b175865a1e">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)</td></tr>
+<tr class="memdesc:a711b443e433977b183c789b175865a1e"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a711b443e433977b183c789b175865a1e">More...</a><br /></td></tr>
+<tr class="separator:a711b443e433977b183c789b175865a1e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1d0808644eb398cf7036a446b853220d"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:a1d0808644eb398cf7036a446b853220d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a1d0808644eb398cf7036a446b853220d">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)</td></tr>
+<tr class="memdesc:a1d0808644eb398cf7036a446b853220d"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a1d0808644eb398cf7036a446b853220d">More...</a><br /></td></tr>
+<tr class="separator:a1d0808644eb398cf7036a446b853220d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8fb31d32467dfe99815ca39b766cafac"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:a8fb31d32467dfe99815ca39b766cafac"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a8fb31d32467dfe99815ca39b766cafac">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)</td></tr>
+<tr class="memdesc:a8fb31d32467dfe99815ca39b766cafac"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a8fb31d32467dfe99815ca39b766cafac">More...</a><br /></td></tr>
+<tr class="separator:a8fb31d32467dfe99815ca39b766cafac"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a40d96a28bc0a1b7d11e267cc1d7bc517"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:a40d96a28bc0a1b7d11e267cc1d7bc517"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a40d96a28bc0a1b7d11e267cc1d7bc517">operator()</a> (T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)</td></tr>
+<tr class="memdesc:a40d96a28bc0a1b7d11e267cc1d7bc517"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a40d96a28bc0a1b7d11e267cc1d7bc517">More...</a><br /></td></tr>
+<tr class="separator:a40d96a28bc0a1b7d11e267cc1d7bc517"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a> (const T_functor & _A_functor)</td></tr>
+<tr class="memdesc:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an adaptor that wraps the passed functor. <a href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">More...</a><br /></td></tr>
+<tr class="separator:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:afbbf5b4d89cf98a1224da5d72554afdc"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__argument.html">bound_argument</a>< T_bound > </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#afbbf5b4d89cf98a1224da5d72554afdc">bound_</a></td></tr>
+<tr class="memdesc:afbbf5b4d89cf98a1224da5d72554afdc"><td class="mdescLeft"> </td><td class="mdescRight">The argument bound to the functor. <a href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#afbbf5b4d89cf98a1224da5d72554afdc">More...</a><br /></td></tr>
+<tr class="separator:afbbf5b4d89cf98a1224da5d72554afdc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_attribs_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td></tr>
+<tr class="memdesc:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that is invoked from operator()(). <a href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">More...</a><br /></td></tr>
+<tr class="separator:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_functor, class T_bound><br />
+struct sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></h3>
+
+<p>Adaptor that binds an argument to the wrapped functor. </p>
+<p>This template specialization fixes the 1st argument of the wrapped functor. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="ac6004db92703257f83addd412037f1f7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac6004db92703257f83addd412037f1f7">◆ </a></span>adaptor_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_bound > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1adapts.html">adapts</a><T_functor>::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> <a class="el" href="structsigc_1_1bind__functor.html">sigc::bind_functor</a>< 0, T_functor, T_bound, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a1c6d091ffd70c23930cf6e2b9042d466"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1c6d091ffd70c23930cf6e2b9042d466">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_bound > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef adaptor_type::result_type <a class="el" href="structsigc_1_1bind__functor.html">sigc::bind_functor</a>< 0, T_functor, T_bound, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="ac170bca0fe2af4722cf6e1fd6b3de128"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac170bca0fe2af4722cf6e1fd6b3de128">◆ </a></span>bind_functor()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_bound > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1bind__functor.html">sigc::bind_functor</a>< 0, T_functor, T_bound, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::<a class="el" href="structsigc_1_1bind__functor.html">bind_functor</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_functor > </td>
+ <td class="paramname"><em>_A_func</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_bound > </td>
+ <td class="paramname"><em>_A_bound</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="structsigc_1_1bind__functor.html" title="Adaptor that binds an argument to the wrapped functor.">bind_functor</a> object that binds an argument to the passed functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Functor to invoke from <a class="el" href="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a0f1c2891d52c9f564e571209dbef6f54" title="Invokes the wrapped functor passing on the bound argument only.">operator()()</a>. </td></tr>
+ <tr><td class="paramname">_A_bound</td><td>Argument to bind to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a0f1c2891d52c9f564e571209dbef6f54"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0f1c2891d52c9f564e571209dbef6f54">◆ </a></span>operator()() <span class="overload">[1/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_bound > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> <a class="el" href="structsigc_1_1bind__functor.html">sigc::bind_functor</a>< 0, T_functor, T_bound, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator() </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the bound argument only. </p>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="adf9d663d20ff816a2a4c7d8ffb567eb3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#adf9d663d20ff816a2a4c7d8ffb567eb3">◆ </a></span>operator()() <span class="overload">[2/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_bound > </div>
+<div class="memtemplate">
+template <class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1>::type <a class="el" href="structsigc_1_1bind__functor.html">sigc::bind_functor</a>< 0, T_functor, T_bound, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_arg1</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<p>bound_ is passed as the 1st argument. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_arg1</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a2f2685399ae595b5e51a3af8c2610481"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2f2685399ae595b5e51a3af8c2610481">◆ </a></span>operator()() <span class="overload">[3/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_bound > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2>::type <a class="el" href="structsigc_1_1bind__functor.html">sigc::bind_functor</a>< 0, T_functor, T_bound, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_arg1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_arg2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<p>bound_ is passed as the 1st argument. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_arg1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg2</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a711b443e433977b183c789b175865a1e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a711b443e433977b183c789b175865a1e">◆ </a></span>operator()() <span class="overload">[4/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_bound > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3>::type <a class="el" href="structsigc_1_1bind__functor.html">sigc::bind_functor</a>< 0, T_functor, T_bound, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_arg1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_arg2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_arg3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<p>bound_ is passed as the 1st argument. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_arg1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg3</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a1d0808644eb398cf7036a446b853220d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1d0808644eb398cf7036a446b853220d">◆ </a></span>operator()() <span class="overload">[5/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_bound > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4>::type <a class="el" href="structsigc_1_1bind__functor.html">sigc::bind_functor</a>< 0, T_functor, T_bound, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_arg1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_arg2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_arg3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_arg4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<p>bound_ is passed as the 1st argument. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_arg1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg4</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a8fb31d32467dfe99815ca39b766cafac"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8fb31d32467dfe99815ca39b766cafac">◆ </a></span>operator()() <span class="overload">[6/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_bound > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type <a class="el" href="structsigc_1_1bind__functor.html">sigc::bind_functor</a>< 0, T_functor, T_bound, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_arg1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_arg2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_arg3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_arg4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_arg5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<p>bound_ is passed as the 1st argument. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_arg1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg4</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg5</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a40d96a28bc0a1b7d11e267cc1d7bc517"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a40d96a28bc0a1b7d11e267cc1d7bc517">◆ </a></span>operator()() <span class="overload">[7/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_bound > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type <a class="el" href="structsigc_1_1bind__functor.html">sigc::bind_functor</a>< 0, T_functor, T_bound, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_arg1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_arg2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_arg3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_arg4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_arg5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg6 </td>
+ <td class="paramname"><em>_A_arg6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<p>bound_ is passed as the 1st argument. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_arg1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg4</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg5</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_arg6</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="afbbf5b4d89cf98a1224da5d72554afdc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#afbbf5b4d89cf98a1224da5d72554afdc">◆ </a></span>bound_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_bound > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__argument.html">bound_argument</a><T_bound> <a class="el" href="structsigc_1_1bind__functor.html">sigc::bind_functor</a>< 0, T_functor, T_bound, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a>, <a class="el" href="structsigc_1_1nil.html">nil</a> >::bound_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+<p>The argument bound to the functor. </p>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1bind__return__functor.html">bind_return_functor</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::bind_return_functor< T_return, T_functor > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1bind__return__functor.html">sigc::bind_return_functor< T_return, T_functor ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a>(const T_functor & _A_functor)</td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1bind__return__functor.html#a1fa9551283794b249cbbdf7d270745d4">bind_return_functor</a>(type_trait_take_t< T_functor > _A_functor, type_trait_take_t< T_return > _A_ret_value)</td><td class="entry"><a class="el" href="structsigc_1_1bind__return__functor.html">sigc::bind_return_functor< T_return, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1bind__return__functor.html#a35959a6f4d5f6ddc83f603ee67d25981">operator()</a>()</td><td class="entry"><a class="el" href="structsigc_1_1bind__return__functor.html">sigc::bind_return_functor< T_return, T_functor ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1bind__return__functor.html#aea28cfb0443ae04982fc47c9955303fe">operator()</a>(T_arg1 _A_a1)</td><td class="entry"><a class="el" href="structsigc_1_1bind__return__functor.html">sigc::bind_return_functor< T_return, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1bind__return__functor.html#a0794dd9e28353fd8b9a7454b2621343e">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2)</td><td class="entry"><a class="el" href="structsigc_1_1bind__return__functor.html">sigc::bind_return_functor< T_return, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1bind__return__functor.html#aa1fddb53a22007f28b4a79949ecd5d4c">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)</td><td class="entry"><a class="el" href="structsigc_1_1bind__return__functor.html">sigc::bind_return_functor< T_return, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1bind__return__functor.html#a82f9312afce202883c1f6431b3b6d1c6">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)</td><td class="entry"><a class="el" href="structsigc_1_1bind__return__functor.html">sigc::bind_return_functor< T_return, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1bind__return__functor.html#a87958210a6c240fd56e7386184b8da00">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)</td><td class="entry"><a class="el" href="structsigc_1_1bind__return__functor.html">sigc::bind_return_functor< T_return, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1bind__return__functor.html#a58f654259665ed6f02df042c5b00f888">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)</td><td class="entry"><a class="el" href="structsigc_1_1bind__return__functor.html">sigc::bind_return_functor< T_return, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1bind__return__functor.html#a1b9d2dc672b8dfd7c769bbcedf25d8aa">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)</td><td class="entry"><a class="el" href="structsigc_1_1bind__return__functor.html">sigc::bind_return_functor< T_return, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1bind__return__functor.html#a4fe6cb8d80573ae7abe934ba54879592">result_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1bind__return__functor.html">sigc::bind_return_functor< T_return, T_functor ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1bind__return__functor.html#aa7b8287c19d98cec75a7e64a9464772e">ret_value_</a></td><td class="entry"><a class="el" href="structsigc_1_1bind__return__functor.html">sigc::bind_return_functor< T_return, T_functor ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::bind_return_functor< T_return, T_functor > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1bind__return__functor.html">bind_return_functor</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="structsigc_1_1bind__return__functor-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::bind_return_functor< T_return, T_functor > Struct Template Reference<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a> » <a class="el" href="group__bind.html">bind(), bind_return()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Adaptor that fixes the return value of the wrapped functor.
+ <a href="structsigc_1_1bind__return__functor.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/bind_return.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::bind_return_functor< T_return, T_functor >:</div>
+<div class="dyncontent">
+<div class="center"><img src="structsigc_1_1bind__return__functor__inherit__graph.png" border="0" usemap="#asigc_1_1bind__return__functor_3_01T__return_00_01T__functor_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1bind__return__functor_3_01T__return_00_01T__functor_01_4_inherit__map" id="asigc_1_1bind__return__functor_3_01T__return_00_01T__functor_01_4_inherit__map">
+<area shape="rect" title="Adaptor that fixes the return value of the wrapped functor." alt="" coords="9,229,192,271"/>
+<area shape="rect" href="structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="5,155,196,181"/>
+<area shape="rect" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="29,80,173,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="31,5,171,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a4fe6cb8d80573ae7abe934ba54879592"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1unwrap__reference.html">unwrap_reference</a>< T_return >::type </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__return__functor.html#a4fe6cb8d80573ae7abe934ba54879592">result_type</a></td></tr>
+<tr class="separator:a4fe6cb8d80573ae7abe934ba54879592"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td></tr>
+<tr class="separator:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td></tr>
+<tr class="separator:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a1fa9551283794b249cbbdf7d270745d4"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__return__functor.html#a1fa9551283794b249cbbdf7d270745d4">bind_return_functor</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_functor > _A_functor, <a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_return > _A_ret_value)</td></tr>
+<tr class="memdesc:a1fa9551283794b249cbbdf7d270745d4"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="structsigc_1_1bind__return__functor.html" title="Adaptor that fixes the return value of the wrapped functor.">bind_return_functor</a> object that fixes the return value to <code>_A_ret_value</code>. <a href="structsigc_1_1bind__return__functor.html#a1fa9551283794b249cbbdf7d270745d4">More...</a><br /></td></tr>
+<tr class="separator:a1fa9551283794b249cbbdf7d270745d4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a35959a6f4d5f6ddc83f603ee67d25981"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1unwrap__reference.html">unwrap_reference</a>< T_return >::type </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__return__functor.html#a35959a6f4d5f6ddc83f603ee67d25981">operator()</a> ()</td></tr>
+<tr class="memdesc:a35959a6f4d5f6ddc83f603ee67d25981"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor dropping its return value. <a href="structsigc_1_1bind__return__functor.html#a35959a6f4d5f6ddc83f603ee67d25981">More...</a><br /></td></tr>
+<tr class="separator:a35959a6f4d5f6ddc83f603ee67d25981"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aea28cfb0443ae04982fc47c9955303fe"><td class="memTemplParams" colspan="2">template<class T_arg1 > </td></tr>
+<tr class="memitem:aea28cfb0443ae04982fc47c9955303fe"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1unwrap__reference.html">unwrap_reference</a>< T_return >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__return__functor.html#aea28cfb0443ae04982fc47c9955303fe">operator()</a> (T_arg1 _A_a1)</td></tr>
+<tr class="memdesc:aea28cfb0443ae04982fc47c9955303fe"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="structsigc_1_1bind__return__functor.html#aea28cfb0443ae04982fc47c9955303fe">More...</a><br /></td></tr>
+<tr class="separator:aea28cfb0443ae04982fc47c9955303fe"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0794dd9e28353fd8b9a7454b2621343e"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:a0794dd9e28353fd8b9a7454b2621343e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1unwrap__reference.html">unwrap_reference</a>< T_return >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__return__functor.html#a0794dd9e28353fd8b9a7454b2621343e">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2)</td></tr>
+<tr class="memdesc:a0794dd9e28353fd8b9a7454b2621343e"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="structsigc_1_1bind__return__functor.html#a0794dd9e28353fd8b9a7454b2621343e">More...</a><br /></td></tr>
+<tr class="separator:a0794dd9e28353fd8b9a7454b2621343e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa1fddb53a22007f28b4a79949ecd5d4c"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:aa1fddb53a22007f28b4a79949ecd5d4c"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1unwrap__reference.html">unwrap_reference</a>< T_return >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__return__functor.html#aa1fddb53a22007f28b4a79949ecd5d4c">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)</td></tr>
+<tr class="memdesc:aa1fddb53a22007f28b4a79949ecd5d4c"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="structsigc_1_1bind__return__functor.html#aa1fddb53a22007f28b4a79949ecd5d4c">More...</a><br /></td></tr>
+<tr class="separator:aa1fddb53a22007f28b4a79949ecd5d4c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a82f9312afce202883c1f6431b3b6d1c6"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:a82f9312afce202883c1f6431b3b6d1c6"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1unwrap__reference.html">unwrap_reference</a>< T_return >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__return__functor.html#a82f9312afce202883c1f6431b3b6d1c6">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)</td></tr>
+<tr class="memdesc:a82f9312afce202883c1f6431b3b6d1c6"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="structsigc_1_1bind__return__functor.html#a82f9312afce202883c1f6431b3b6d1c6">More...</a><br /></td></tr>
+<tr class="separator:a82f9312afce202883c1f6431b3b6d1c6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87958210a6c240fd56e7386184b8da00"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:a87958210a6c240fd56e7386184b8da00"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1unwrap__reference.html">unwrap_reference</a>< T_return >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__return__functor.html#a87958210a6c240fd56e7386184b8da00">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)</td></tr>
+<tr class="memdesc:a87958210a6c240fd56e7386184b8da00"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="structsigc_1_1bind__return__functor.html#a87958210a6c240fd56e7386184b8da00">More...</a><br /></td></tr>
+<tr class="separator:a87958210a6c240fd56e7386184b8da00"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a58f654259665ed6f02df042c5b00f888"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:a58f654259665ed6f02df042c5b00f888"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1unwrap__reference.html">unwrap_reference</a>< T_return >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__return__functor.html#a58f654259665ed6f02df042c5b00f888">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)</td></tr>
+<tr class="memdesc:a58f654259665ed6f02df042c5b00f888"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="structsigc_1_1bind__return__functor.html#a58f654259665ed6f02df042c5b00f888">More...</a><br /></td></tr>
+<tr class="separator:a58f654259665ed6f02df042c5b00f888"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1b9d2dc672b8dfd7c769bbcedf25d8aa"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:a1b9d2dc672b8dfd7c769bbcedf25d8aa"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1unwrap__reference.html">unwrap_reference</a>< T_return >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__return__functor.html#a1b9d2dc672b8dfd7c769bbcedf25d8aa">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)</td></tr>
+<tr class="memdesc:a1b9d2dc672b8dfd7c769bbcedf25d8aa"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor passing on the arguments. <a href="structsigc_1_1bind__return__functor.html#a1b9d2dc672b8dfd7c769bbcedf25d8aa">More...</a><br /></td></tr>
+<tr class="separator:a1b9d2dc672b8dfd7c769bbcedf25d8aa"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a> (const T_functor & _A_functor)</td></tr>
+<tr class="memdesc:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an adaptor that wraps the passed functor. <a href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">More...</a><br /></td></tr>
+<tr class="separator:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:aa7b8287c19d98cec75a7e64a9464772e"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classsigc_1_1bound__argument.html">bound_argument</a>< T_return > </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1bind__return__functor.html#aa7b8287c19d98cec75a7e64a9464772e">ret_value_</a></td></tr>
+<tr class="memdesc:aa7b8287c19d98cec75a7e64a9464772e"><td class="mdescLeft"> </td><td class="mdescRight">The fixed return value. <a href="structsigc_1_1bind__return__functor.html#aa7b8287c19d98cec75a7e64a9464772e">More...</a><br /></td></tr>
+<tr class="separator:aa7b8287c19d98cec75a7e64a9464772e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_attribs_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td></tr>
+<tr class="memdesc:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that is invoked from operator()(). <a href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">More...</a><br /></td></tr>
+<tr class="separator:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_functor><br />
+struct sigc::bind_return_functor< T_return, T_functor ></h3>
+
+<p>Adaptor that fixes the return value of the wrapped functor. </p>
+<p>Use the convenience function <a class="el" href="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a" title="Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed funct...">sigc::bind_return()</a> to create an instance of <a class="el" href="structsigc_1_1bind__return__functor.html" title="Adaptor that fixes the return value of the wrapped functor.">sigc::bind_return_functor</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_return</em> Type of the fixed return value.</li>
+<li><em>T_functor</em> Type of the functor to wrap. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a4fe6cb8d80573ae7abe934ba54879592"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4fe6cb8d80573ae7abe934ba54879592">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_functor > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1unwrap__reference.html">unwrap_reference</a><T_return>::type <a class="el" href="structsigc_1_1bind__return__functor.html">sigc::bind_return_functor</a>< T_return, T_functor >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a1fa9551283794b249cbbdf7d270745d4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1fa9551283794b249cbbdf7d270745d4">◆ </a></span>bind_return_functor()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1bind__return__functor.html">sigc::bind_return_functor</a>< T_return, T_functor >::<a class="el" href="structsigc_1_1bind__return__functor.html">bind_return_functor</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_functor > </td>
+ <td class="paramname"><em>_A_functor</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_return > </td>
+ <td class="paramname"><em>_A_ret_value</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="structsigc_1_1bind__return__functor.html" title="Adaptor that fixes the return value of the wrapped functor.">bind_return_functor</a> object that fixes the return value to <code>_A_ret_value</code>. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor to invoke from <a class="el" href="structsigc_1_1bind__return__functor.html#a35959a6f4d5f6ddc83f603ee67d25981" title="Invokes the wrapped functor dropping its return value.">operator()()</a>. </td></tr>
+ <tr><td class="paramname">_A_ret_value</td><td>Value to return from <a class="el" href="structsigc_1_1bind__return__functor.html#a35959a6f4d5f6ddc83f603ee67d25981" title="Invokes the wrapped functor dropping its return value.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a35959a6f4d5f6ddc83f603ee67d25981"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a35959a6f4d5f6ddc83f603ee67d25981">◆ </a></span>operator()() <span class="overload">[1/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_functor > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1unwrap__reference.html">unwrap_reference</a>< T_return >::type <a class="el" href="structsigc_1_1bind__return__functor.html">sigc::bind_return_functor</a>< T_return, T_functor >::operator()</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor dropping its return value. </p>
+<dl class="section return"><dt>Returns</dt><dd>The fixed return value. </dd></dl>
+
+</div>
+</div>
+<a id="aea28cfb0443ae04982fc47c9955303fe"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aea28cfb0443ae04982fc47c9955303fe">◆ </a></span>operator()() <span class="overload">[2/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1unwrap__reference.html">unwrap_reference</a><T_return>::type <a class="el" href="structsigc_1_1bind__return__functor.html">sigc::bind_return_functor</a>< T_return, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The fixed return value. </dd></dl>
+
+</div>
+</div>
+<a id="a0794dd9e28353fd8b9a7454b2621343e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0794dd9e28353fd8b9a7454b2621343e">◆ </a></span>operator()() <span class="overload">[3/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1unwrap__reference.html">unwrap_reference</a><T_return>::type <a class="el" href="structsigc_1_1bind__return__functor.html">sigc::bind_return_functor</a>< T_return, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The fixed return value. </dd></dl>
+
+</div>
+</div>
+<a id="aa1fddb53a22007f28b4a79949ecd5d4c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa1fddb53a22007f28b4a79949ecd5d4c">◆ </a></span>operator()() <span class="overload">[4/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1unwrap__reference.html">unwrap_reference</a><T_return>::type <a class="el" href="structsigc_1_1bind__return__functor.html">sigc::bind_return_functor</a>< T_return, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The fixed return value. </dd></dl>
+
+</div>
+</div>
+<a id="a82f9312afce202883c1f6431b3b6d1c6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a82f9312afce202883c1f6431b3b6d1c6">◆ </a></span>operator()() <span class="overload">[5/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1unwrap__reference.html">unwrap_reference</a><T_return>::type <a class="el" href="structsigc_1_1bind__return__functor.html">sigc::bind_return_functor</a>< T_return, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The fixed return value. </dd></dl>
+
+</div>
+</div>
+<a id="a87958210a6c240fd56e7386184b8da00"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a87958210a6c240fd56e7386184b8da00">◆ </a></span>operator()() <span class="overload">[6/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1unwrap__reference.html">unwrap_reference</a><T_return>::type <a class="el" href="structsigc_1_1bind__return__functor.html">sigc::bind_return_functor</a>< T_return, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The fixed return value. </dd></dl>
+
+</div>
+</div>
+<a id="a58f654259665ed6f02df042c5b00f888"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a58f654259665ed6f02df042c5b00f888">◆ </a></span>operator()() <span class="overload">[7/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1unwrap__reference.html">unwrap_reference</a><T_return>::type <a class="el" href="structsigc_1_1bind__return__functor.html">sigc::bind_return_functor</a>< T_return, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg6 </td>
+ <td class="paramname"><em>_A_a6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The fixed return value. </dd></dl>
+
+</div>
+</div>
+<a id="a1b9d2dc672b8dfd7c769bbcedf25d8aa"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1b9d2dc672b8dfd7c769bbcedf25d8aa">◆ </a></span>operator()() <span class="overload">[8/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1unwrap__reference.html">unwrap_reference</a><T_return>::type <a class="el" href="structsigc_1_1bind__return__functor.html">sigc::bind_return_functor</a>< T_return, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg6 </td>
+ <td class="paramname"><em>_A_a6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg7 </td>
+ <td class="paramname"><em>_A_a7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor passing on the arguments. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a7</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The fixed return value. </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="aa7b8287c19d98cec75a7e64a9464772e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa7b8287c19d98cec75a7e64a9464772e">◆ </a></span>ret_value_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_functor > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="classsigc_1_1bound__argument.html">bound_argument</a><T_return> <a class="el" href="structsigc_1_1bind__return__functor.html">sigc::bind_return_functor</a>< T_return, T_functor >::ret_value_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+<p>The fixed return value. </p>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:57 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::bind_return_functor< T_return, T_functor >" name="sigc::bind_return_functor< T_return, T_functor >">
+<area shape="rect" id="node1" title="Adaptor that fixes the return value of the wrapped functor." alt="" coords="9,229,192,271"/>
+<area shape="rect" id="node2" href="$structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="5,155,196,181"/>
+<area shape="rect" id="node3" href="$structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="29,80,173,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="31,5,171,32"/>
+</map>
--- /dev/null
+9cdf1f368796e1ea74fbb7e20e47341f
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1compose1__functor.html">compose1_functor</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::compose1_functor< T_setter, T_getter > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor< T_setter, T_getter ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1compose1__functor.html#a90d506f177dca8afeaef61b6b5956541">adaptor_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor< T_setter, T_getter ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a>(const T_setter & _A_functor)</td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_setter ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1compose1__functor.html#a1bb831ebfb46a214a6ffda98e77ad044">compose1_functor</a>(const T_setter & _A_setter, const T_getter & _A_getter)</td><td class="entry"><a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor< T_setter, T_getter ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_setter ></a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1compose1__functor.html#abc9151caeb78b1cd79ce1eb6984dc066">get_</a></td><td class="entry"><a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor< T_setter, T_getter ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1compose1__functor.html#ad54c2d62658fb7a47da41df0ccfc618c">getter_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor< T_setter, T_getter ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1compose1__functor.html#ae7c074e7656595157b0f421028e34609">operator()</a>()</td><td class="entry"><a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor< T_setter, T_getter ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1compose1__functor.html#ab32178c24587037b5ae30b8b807f5a35">operator()</a>(T_arg1 _A_a1)</td><td class="entry"><a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor< T_setter, T_getter ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1compose1__functor.html#afff816d0f3e6959be7c5f268559f3e2f">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2)</td><td class="entry"><a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor< T_setter, T_getter ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1compose1__functor.html#aa53fd7a2a0b51d8c0c0e4568559292b7">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)</td><td class="entry"><a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor< T_setter, T_getter ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1compose1__functor.html#a4bc76b086fdcf3f823b055b9d6e76dab">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)</td><td class="entry"><a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor< T_setter, T_getter ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1compose1__functor.html#aebb21782ac3e60c4f817de69a316a711">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)</td><td class="entry"><a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor< T_setter, T_getter ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1compose1__functor.html#a70de905fa8c830cecf3526704c4290de">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)</td><td class="entry"><a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor< T_setter, T_getter ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1compose1__functor.html#afe1dd6cb126a8c401355b7b1c189a5d9">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)</td><td class="entry"><a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor< T_setter, T_getter ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1compose1__functor.html#ab096c0a388f877d97b3812f2fcc813f9">result_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor< T_setter, T_getter ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1compose1__functor.html#a86a8bc8f4926f7bb91ef362fff03a25e">setter_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor< T_setter, T_getter ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::compose1_functor< T_setter, T_getter > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1compose1__functor.html">compose1_functor</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="structsigc_1_1compose1__functor-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::compose1_functor< T_setter, T_getter > Struct Template Reference<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a> » <a class="el" href="group__compose.html">compose()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Adaptor that combines two functors.
+ <a href="structsigc_1_1compose1__functor.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/compose.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::compose1_functor< T_setter, T_getter >:</div>
+<div class="dyncontent">
+<div class="center"><img src="structsigc_1_1compose1__functor__inherit__graph.png" border="0" usemap="#asigc_1_1compose1__functor_3_01T__setter_00_01T__getter_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1compose1__functor_3_01T__setter_00_01T__getter_01_4_inherit__map" id="asigc_1_1compose1__functor_3_01T__setter_00_01T__getter_01_4_inherit__map">
+<area shape="rect" title="Adaptor that combines two functors." alt="" coords="9,229,185,271"/>
+<area shape="rect" href="structsigc_1_1adapts.html" title=" " alt="" coords="5,155,188,181"/>
+<area shape="rect" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="25,80,169,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="27,5,167,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a90d506f177dca8afeaef61b6b5956541"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adapts.html">adapts</a>< T_setter >::<a class="el" href="structsigc_1_1compose1__functor.html#a90d506f177dca8afeaef61b6b5956541">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose1__functor.html#a90d506f177dca8afeaef61b6b5956541">adaptor_type</a></td></tr>
+<tr class="separator:a90d506f177dca8afeaef61b6b5956541"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad54c2d62658fb7a47da41df0ccfc618c"><td class="memItemLeft" align="right" valign="top">typedef T_getter </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose1__functor.html#ad54c2d62658fb7a47da41df0ccfc618c">getter_type</a></td></tr>
+<tr class="separator:ad54c2d62658fb7a47da41df0ccfc618c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab096c0a388f877d97b3812f2fcc813f9"><td class="memItemLeft" align="right" valign="top">typedef adaptor_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose1__functor.html#ab096c0a388f877d97b3812f2fcc813f9">result_type</a></td></tr>
+<tr class="separator:ab096c0a388f877d97b3812f2fcc813f9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a86a8bc8f4926f7bb91ef362fff03a25e"><td class="memItemLeft" align="right" valign="top">typedef T_setter </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose1__functor.html#a86a8bc8f4926f7bb91ef362fff03a25e">setter_type</a></td></tr>
+<tr class="separator:a86a8bc8f4926f7bb91ef362fff03a25e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_setter ></a></td></tr>
+<tr class="memitem:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_setter >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td></tr>
+<tr class="separator:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_setter >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td></tr>
+<tr class="separator:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a1bb831ebfb46a214a6ffda98e77ad044"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose1__functor.html#a1bb831ebfb46a214a6ffda98e77ad044">compose1_functor</a> (const T_setter & _A_setter, const T_getter & _A_getter)</td></tr>
+<tr class="memdesc:a1bb831ebfb46a214a6ffda98e77ad044"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="structsigc_1_1compose1__functor.html" title="Adaptor that combines two functors.">compose1_functor</a> object that combines the passed functors. <a href="structsigc_1_1compose1__functor.html#a1bb831ebfb46a214a6ffda98e77ad044">More...</a><br /></td></tr>
+<tr class="separator:a1bb831ebfb46a214a6ffda98e77ad044"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae7c074e7656595157b0f421028e34609"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1compose1__functor.html#ab096c0a388f877d97b3812f2fcc813f9">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose1__functor.html#ae7c074e7656595157b0f421028e34609">operator()</a> ()</td></tr>
+<tr class="separator:ae7c074e7656595157b0f421028e34609"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab32178c24587037b5ae30b8b807f5a35"><td class="memTemplParams" colspan="2">template<class T_arg1 > </td></tr>
+<tr class="memitem:ab32178c24587037b5ae30b8b807f5a35"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose1__functor.html#ab32178c24587037b5ae30b8b807f5a35">operator()</a> (T_arg1 _A_a1)</td></tr>
+<tr class="separator:ab32178c24587037b5ae30b8b807f5a35"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afff816d0f3e6959be7c5f268559f3e2f"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:afff816d0f3e6959be7c5f268559f3e2f"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose1__functor.html#afff816d0f3e6959be7c5f268559f3e2f">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2)</td></tr>
+<tr class="separator:afff816d0f3e6959be7c5f268559f3e2f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa53fd7a2a0b51d8c0c0e4568559292b7"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:aa53fd7a2a0b51d8c0c0e4568559292b7"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose1__functor.html#aa53fd7a2a0b51d8c0c0e4568559292b7">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)</td></tr>
+<tr class="separator:aa53fd7a2a0b51d8c0c0e4568559292b7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4bc76b086fdcf3f823b055b9d6e76dab"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:a4bc76b086fdcf3f823b055b9d6e76dab"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose1__functor.html#a4bc76b086fdcf3f823b055b9d6e76dab">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)</td></tr>
+<tr class="separator:a4bc76b086fdcf3f823b055b9d6e76dab"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb21782ac3e60c4f817de69a316a711"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:aebb21782ac3e60c4f817de69a316a711"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose1__functor.html#aebb21782ac3e60c4f817de69a316a711">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)</td></tr>
+<tr class="separator:aebb21782ac3e60c4f817de69a316a711"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a70de905fa8c830cecf3526704c4290de"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:a70de905fa8c830cecf3526704c4290de"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose1__functor.html#a70de905fa8c830cecf3526704c4290de">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)</td></tr>
+<tr class="separator:a70de905fa8c830cecf3526704c4290de"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afe1dd6cb126a8c401355b7b1c189a5d9"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:afe1dd6cb126a8c401355b7b1c189a5d9"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose1__functor.html#afe1dd6cb126a8c401355b7b1c189a5d9">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)</td></tr>
+<tr class="separator:afe1dd6cb126a8c401355b7b1c189a5d9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_setter ></a></td></tr>
+<tr class="memitem:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a> (const T_setter & _A_functor)</td></tr>
+<tr class="memdesc:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an adaptor that wraps the passed functor. <a href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">More...</a><br /></td></tr>
+<tr class="separator:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:abc9151caeb78b1cd79ce1eb6984dc066"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1compose1__functor.html#ad54c2d62658fb7a47da41df0ccfc618c">getter_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose1__functor.html#abc9151caeb78b1cd79ce1eb6984dc066">get_</a></td></tr>
+<tr class="separator:abc9151caeb78b1cd79ce1eb6984dc066"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_attribs_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_setter ></a></td></tr>
+<tr class="memitem:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td></tr>
+<tr class="memdesc:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that is invoked from operator()(). <a href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">More...</a><br /></td></tr>
+<tr class="separator:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_setter, class T_getter><br />
+struct sigc::compose1_functor< T_setter, T_getter ></h3>
+
+<p>Adaptor that combines two functors. </p>
+<p>Use the convenience function <a class="el" href="group__compose.html#ga34cf5da8f6323bfdc41bc7113d6ad20a" title="Creates an adaptor of type sigc::compose1_functor which combines two functors.">sigc::compose()</a> to create an instance of <a class="el" href="structsigc_1_1compose1__functor.html" title="Adaptor that combines two functors.">sigc::compose1_functor</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_setter</em> Type of the setter functor to wrap.</li>
+<li><em>T_getter</em> Type of the getter functor to wrap. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a90d506f177dca8afeaef61b6b5956541"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a90d506f177dca8afeaef61b6b5956541">◆ </a></span>adaptor_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1adapts.html">adapts</a><T_setter>::<a class="el" href="structsigc_1_1compose1__functor.html#a90d506f177dca8afeaef61b6b5956541">adaptor_type</a> <a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor</a>< T_setter, T_getter >::<a class="el" href="structsigc_1_1compose1__functor.html#a90d506f177dca8afeaef61b6b5956541">adaptor_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ad54c2d62658fb7a47da41df0ccfc618c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad54c2d62658fb7a47da41df0ccfc618c">◆ </a></span>getter_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_getter <a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor</a>< T_setter, T_getter >::<a class="el" href="structsigc_1_1compose1__functor.html#ad54c2d62658fb7a47da41df0ccfc618c">getter_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ab096c0a388f877d97b3812f2fcc813f9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab096c0a388f877d97b3812f2fcc813f9">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef adaptor_type::result_type <a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor</a>< T_setter, T_getter >::<a class="el" href="structsigc_1_1compose1__functor.html#ab096c0a388f877d97b3812f2fcc813f9">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a86a8bc8f4926f7bb91ef362fff03a25e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a86a8bc8f4926f7bb91ef362fff03a25e">◆ </a></span>setter_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_setter <a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor</a>< T_setter, T_getter >::<a class="el" href="structsigc_1_1compose1__functor.html#a86a8bc8f4926f7bb91ef362fff03a25e">setter_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a1bb831ebfb46a214a6ffda98e77ad044"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1bb831ebfb46a214a6ffda98e77ad044">◆ </a></span>compose1_functor()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor</a>< T_setter, T_getter >::<a class="el" href="structsigc_1_1compose1__functor.html">compose1_functor</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_setter & </td>
+ <td class="paramname"><em>_A_setter</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_getter & </td>
+ <td class="paramname"><em>_A_getter</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="structsigc_1_1compose1__functor.html" title="Adaptor that combines two functors.">compose1_functor</a> object that combines the passed functors. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_setter</td><td>Functor that receives the return values of the invokation of <em>_A_getter1</em> and <em>_A_getter2</em>. </td></tr>
+ <tr><td class="paramname">_A_getter</td><td>Functor to invoke from <a class="el" href="structsigc_1_1compose1__functor.html#ae7c074e7656595157b0f421028e34609">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="ae7c074e7656595157b0f421028e34609"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae7c074e7656595157b0f421028e34609">◆ </a></span>operator()() <span class="overload">[1/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1compose1__functor.html">compose1_functor</a>< T_setter, T_getter >::<a class="el" href="structsigc_1_1compose1__functor.html#ab096c0a388f877d97b3812f2fcc813f9">result_type</a> <a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor</a>< T_setter, T_getter >::operator()</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ab32178c24587037b5ae30b8b807f5a35"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab32178c24587037b5ae30b8b807f5a35">◆ </a></span>operator()() <span class="overload">[2/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter > </div>
+<div class="memtemplate">
+template <class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1>::type <a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor</a>< T_setter, T_getter >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="afff816d0f3e6959be7c5f268559f3e2f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#afff816d0f3e6959be7c5f268559f3e2f">◆ </a></span>operator()() <span class="overload">[3/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2>::type <a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor</a>< T_setter, T_getter >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aa53fd7a2a0b51d8c0c0e4568559292b7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa53fd7a2a0b51d8c0c0e4568559292b7">◆ </a></span>operator()() <span class="overload">[4/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3>::type <a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor</a>< T_setter, T_getter >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a4bc76b086fdcf3f823b055b9d6e76dab"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4bc76b086fdcf3f823b055b9d6e76dab">◆ </a></span>operator()() <span class="overload">[5/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4>::type <a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor</a>< T_setter, T_getter >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aebb21782ac3e60c4f817de69a316a711"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aebb21782ac3e60c4f817de69a316a711">◆ </a></span>operator()() <span class="overload">[6/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type <a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor</a>< T_setter, T_getter >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a70de905fa8c830cecf3526704c4290de"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a70de905fa8c830cecf3526704c4290de">◆ </a></span>operator()() <span class="overload">[7/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type <a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor</a>< T_setter, T_getter >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg6 </td>
+ <td class="paramname"><em>_A_a6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="afe1dd6cb126a8c401355b7b1c189a5d9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#afe1dd6cb126a8c401355b7b1c189a5d9">◆ </a></span>operator()() <span class="overload">[8/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type <a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor</a>< T_setter, T_getter >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg6 </td>
+ <td class="paramname"><em>_A_a6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg7 </td>
+ <td class="paramname"><em>_A_a7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="abc9151caeb78b1cd79ce1eb6984dc066"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abc9151caeb78b1cd79ce1eb6984dc066">◆ </a></span>get_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1compose1__functor.html#ad54c2d62658fb7a47da41df0ccfc618c">getter_type</a> <a class="el" href="structsigc_1_1compose1__functor.html">sigc::compose1_functor</a>< T_setter, T_getter >::get_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::compose1_functor< T_setter, T_getter >" name="sigc::compose1_functor< T_setter, T_getter >">
+<area shape="rect" id="node1" title="Adaptor that combines two functors." alt="" coords="9,229,185,271"/>
+<area shape="rect" id="node2" href="$structsigc_1_1adapts.html" title=" " alt="" coords="5,155,188,181"/>
+<area shape="rect" id="node3" href="$structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="25,80,169,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="27,5,167,32"/>
+</map>
--- /dev/null
+454b92ffbbb82ca1ecebaa488dee257f
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1compose2__functor.html">compose2_functor</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::compose2_functor< T_setter, T_getter1, T_getter2 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html#ac1c9b3dc43cc75ec65fe0708fb4450d8">adaptor_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a>(const T_setter & _A_functor)</td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_setter ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html#a72719db97ab3ffdc0176ea3b443ffb60">compose2_functor</a>(const T_setter & _A_setter, const T_getter1 & _A_getter1, const T_getter2 & _A_getter2)</td><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_setter ></a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html#af5404ffb509175690aa896932571e8bf">get1_</a></td><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html#af8404295ebbcb968a798c9fdf3f3d527">get2_</a></td><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html#ab7ab82eee45e8df9116a5a2b7c12c39c">getter1_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html#a75e252684d06f75f036043df56d8df69">getter2_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html#a3cfcfa7d8d95962b3448ed886f3495a0">operator()</a>()</td><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html#adfcd11f81cefb39743d9467d21510c53">operator()</a>(T_arg1 _A_a1)</td><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html#a048e0ff176de0813c190279afd7e16dd">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2)</td><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html#a48c102ded15a30326d7daefa8b817dd3">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)</td><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html#aaa7e4c7aae30b0585039655a71ed6850">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)</td><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html#acb668cbfa312852668695eda2198c64b">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)</td><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html#af0cfb941c315a47381eaa288bfd87428">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)</td><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html#af39ab33c42d6e7c715b9f5e8ba4eb556">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)</td><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html#a78ccb07f23696a452df9f61308885542">result_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html#ac3d7308c702df7378af1635281d5f7b8">setter_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::compose2_functor< T_setter, T_getter1, T_getter2 > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1compose2__functor.html">compose2_functor</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="structsigc_1_1compose2__functor-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::compose2_functor< T_setter, T_getter1, T_getter2 > Struct Template Reference<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a> » <a class="el" href="group__compose.html">compose()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Adaptor that combines three functors.
+ <a href="structsigc_1_1compose2__functor.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/compose.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::compose2_functor< T_setter, T_getter1, T_getter2 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="structsigc_1_1compose2__functor__inherit__graph.png" border="0" usemap="#asigc_1_1compose2__functor_3_01T__setter_00_01T__getter1_00_01T__getter2_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1compose2__functor_3_01T__setter_00_01T__getter1_00_01T__getter2_01_4_inherit__map" id="asigc_1_1compose2__functor_3_01T__setter_00_01T__getter1_00_01T__getter2_01_4_inherit__map">
+<area shape="rect" title="Adaptor that combines three functors." alt="" coords="9,229,185,285"/>
+<area shape="rect" href="structsigc_1_1adapts.html" title=" " alt="" coords="5,155,188,181"/>
+<area shape="rect" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="25,80,169,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="27,5,167,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:ac1c9b3dc43cc75ec65fe0708fb4450d8"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adapts.html">adapts</a>< T_setter >::<a class="el" href="structsigc_1_1compose2__functor.html#ac1c9b3dc43cc75ec65fe0708fb4450d8">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose2__functor.html#ac1c9b3dc43cc75ec65fe0708fb4450d8">adaptor_type</a></td></tr>
+<tr class="separator:ac1c9b3dc43cc75ec65fe0708fb4450d8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab7ab82eee45e8df9116a5a2b7c12c39c"><td class="memItemLeft" align="right" valign="top">typedef T_getter1 </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose2__functor.html#ab7ab82eee45e8df9116a5a2b7c12c39c">getter1_type</a></td></tr>
+<tr class="separator:ab7ab82eee45e8df9116a5a2b7c12c39c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75e252684d06f75f036043df56d8df69"><td class="memItemLeft" align="right" valign="top">typedef T_getter2 </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose2__functor.html#a75e252684d06f75f036043df56d8df69">getter2_type</a></td></tr>
+<tr class="separator:a75e252684d06f75f036043df56d8df69"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a78ccb07f23696a452df9f61308885542"><td class="memItemLeft" align="right" valign="top">typedef adaptor_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose2__functor.html#a78ccb07f23696a452df9f61308885542">result_type</a></td></tr>
+<tr class="separator:a78ccb07f23696a452df9f61308885542"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d7308c702df7378af1635281d5f7b8"><td class="memItemLeft" align="right" valign="top">typedef T_setter </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose2__functor.html#ac3d7308c702df7378af1635281d5f7b8">setter_type</a></td></tr>
+<tr class="separator:ac3d7308c702df7378af1635281d5f7b8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_setter ></a></td></tr>
+<tr class="memitem:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_setter >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td></tr>
+<tr class="separator:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_setter >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td></tr>
+<tr class="separator:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a72719db97ab3ffdc0176ea3b443ffb60"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose2__functor.html#a72719db97ab3ffdc0176ea3b443ffb60">compose2_functor</a> (const T_setter & _A_setter, const T_getter1 & _A_getter1, const T_getter2 & _A_getter2)</td></tr>
+<tr class="memdesc:a72719db97ab3ffdc0176ea3b443ffb60"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="structsigc_1_1compose2__functor.html" title="Adaptor that combines three functors.">compose2_functor</a> object that combines the passed functors. <a href="structsigc_1_1compose2__functor.html#a72719db97ab3ffdc0176ea3b443ffb60">More...</a><br /></td></tr>
+<tr class="separator:a72719db97ab3ffdc0176ea3b443ffb60"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3cfcfa7d8d95962b3448ed886f3495a0"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1compose2__functor.html#a78ccb07f23696a452df9f61308885542">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose2__functor.html#a3cfcfa7d8d95962b3448ed886f3495a0">operator()</a> ()</td></tr>
+<tr class="separator:a3cfcfa7d8d95962b3448ed886f3495a0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adfcd11f81cefb39743d9467d21510c53"><td class="memTemplParams" colspan="2">template<class T_arg1 > </td></tr>
+<tr class="memitem:adfcd11f81cefb39743d9467d21510c53"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose2__functor.html#adfcd11f81cefb39743d9467d21510c53">operator()</a> (T_arg1 _A_a1)</td></tr>
+<tr class="separator:adfcd11f81cefb39743d9467d21510c53"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a048e0ff176de0813c190279afd7e16dd"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:a048e0ff176de0813c190279afd7e16dd"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose2__functor.html#a048e0ff176de0813c190279afd7e16dd">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2)</td></tr>
+<tr class="separator:a048e0ff176de0813c190279afd7e16dd"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a48c102ded15a30326d7daefa8b817dd3"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:a48c102ded15a30326d7daefa8b817dd3"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose2__functor.html#a48c102ded15a30326d7daefa8b817dd3">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)</td></tr>
+<tr class="separator:a48c102ded15a30326d7daefa8b817dd3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aaa7e4c7aae30b0585039655a71ed6850"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:aaa7e4c7aae30b0585039655a71ed6850"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose2__functor.html#aaa7e4c7aae30b0585039655a71ed6850">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)</td></tr>
+<tr class="separator:aaa7e4c7aae30b0585039655a71ed6850"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acb668cbfa312852668695eda2198c64b"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:acb668cbfa312852668695eda2198c64b"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose2__functor.html#acb668cbfa312852668695eda2198c64b">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)</td></tr>
+<tr class="separator:acb668cbfa312852668695eda2198c64b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af0cfb941c315a47381eaa288bfd87428"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:af0cfb941c315a47381eaa288bfd87428"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose2__functor.html#af0cfb941c315a47381eaa288bfd87428">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)</td></tr>
+<tr class="separator:af0cfb941c315a47381eaa288bfd87428"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af39ab33c42d6e7c715b9f5e8ba4eb556"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:af39ab33c42d6e7c715b9f5e8ba4eb556"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose2__functor.html#af39ab33c42d6e7c715b9f5e8ba4eb556">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)</td></tr>
+<tr class="separator:af39ab33c42d6e7c715b9f5e8ba4eb556"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_setter ></a></td></tr>
+<tr class="memitem:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a> (const T_setter & _A_functor)</td></tr>
+<tr class="memdesc:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an adaptor that wraps the passed functor. <a href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">More...</a><br /></td></tr>
+<tr class="separator:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:af5404ffb509175690aa896932571e8bf"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1compose2__functor.html#ab7ab82eee45e8df9116a5a2b7c12c39c">getter1_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose2__functor.html#af5404ffb509175690aa896932571e8bf">get1_</a></td></tr>
+<tr class="separator:af5404ffb509175690aa896932571e8bf"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af8404295ebbcb968a798c9fdf3f3d527"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1compose2__functor.html#a75e252684d06f75f036043df56d8df69">getter2_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1compose2__functor.html#af8404295ebbcb968a798c9fdf3f3d527">get2_</a></td></tr>
+<tr class="separator:af8404295ebbcb968a798c9fdf3f3d527"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_attribs_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_setter ></a></td></tr>
+<tr class="memitem:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td></tr>
+<tr class="memdesc:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that is invoked from operator()(). <a href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">More...</a><br /></td></tr>
+<tr class="separator:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_setter, class T_getter1, class T_getter2><br />
+struct sigc::compose2_functor< T_setter, T_getter1, T_getter2 ></h3>
+
+<p>Adaptor that combines three functors. </p>
+<p>Use the convenience function <a class="el" href="group__compose.html#ga34cf5da8f6323bfdc41bc7113d6ad20a" title="Creates an adaptor of type sigc::compose1_functor which combines two functors.">sigc::compose()</a> to create an instance of <a class="el" href="structsigc_1_1compose2__functor.html" title="Adaptor that combines three functors.">sigc::compose2_functor</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_setter</em> Type of the setter functor to wrap.</li>
+<li><em>T_getter1</em> Type of the first getter functor to wrap.</li>
+<li><em>T_getter2</em> Type of the second getter functor to wrap. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="ac1c9b3dc43cc75ec65fe0708fb4450d8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac1c9b3dc43cc75ec65fe0708fb4450d8">◆ </a></span>adaptor_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter1 , class T_getter2 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1adapts.html">adapts</a><T_setter>::<a class="el" href="structsigc_1_1compose2__functor.html#ac1c9b3dc43cc75ec65fe0708fb4450d8">adaptor_type</a> <a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor</a>< T_setter, T_getter1, T_getter2 >::<a class="el" href="structsigc_1_1compose2__functor.html#ac1c9b3dc43cc75ec65fe0708fb4450d8">adaptor_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ab7ab82eee45e8df9116a5a2b7c12c39c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab7ab82eee45e8df9116a5a2b7c12c39c">◆ </a></span>getter1_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter1 , class T_getter2 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_getter1 <a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor</a>< T_setter, T_getter1, T_getter2 >::<a class="el" href="structsigc_1_1compose2__functor.html#ab7ab82eee45e8df9116a5a2b7c12c39c">getter1_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a75e252684d06f75f036043df56d8df69"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a75e252684d06f75f036043df56d8df69">◆ </a></span>getter2_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter1 , class T_getter2 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_getter2 <a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor</a>< T_setter, T_getter1, T_getter2 >::<a class="el" href="structsigc_1_1compose2__functor.html#a75e252684d06f75f036043df56d8df69">getter2_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a78ccb07f23696a452df9f61308885542"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a78ccb07f23696a452df9f61308885542">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter1 , class T_getter2 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef adaptor_type::result_type <a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor</a>< T_setter, T_getter1, T_getter2 >::<a class="el" href="structsigc_1_1compose2__functor.html#a78ccb07f23696a452df9f61308885542">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ac3d7308c702df7378af1635281d5f7b8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac3d7308c702df7378af1635281d5f7b8">◆ </a></span>setter_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter1 , class T_getter2 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_setter <a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor</a>< T_setter, T_getter1, T_getter2 >::<a class="el" href="structsigc_1_1compose2__functor.html#ac3d7308c702df7378af1635281d5f7b8">setter_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a72719db97ab3ffdc0176ea3b443ffb60"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a72719db97ab3ffdc0176ea3b443ffb60">◆ </a></span>compose2_functor()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter1 , class T_getter2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor</a>< T_setter, T_getter1, T_getter2 >::<a class="el" href="structsigc_1_1compose2__functor.html">compose2_functor</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_setter & </td>
+ <td class="paramname"><em>_A_setter</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_getter1 & </td>
+ <td class="paramname"><em>_A_getter1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_getter2 & </td>
+ <td class="paramname"><em>_A_getter2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="structsigc_1_1compose2__functor.html" title="Adaptor that combines three functors.">compose2_functor</a> object that combines the passed functors. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_setter</td><td>Functor that receives the return values of the invokation of <em>_A_getter1</em> and <em>_A_getter2</em>. </td></tr>
+ <tr><td class="paramname">_A_getter1</td><td>Functor to invoke from <a class="el" href="structsigc_1_1compose2__functor.html#a3cfcfa7d8d95962b3448ed886f3495a0">operator()()</a>. </td></tr>
+ <tr><td class="paramname">_A_getter2</td><td>Functor to invoke from <a class="el" href="structsigc_1_1compose2__functor.html#a3cfcfa7d8d95962b3448ed886f3495a0">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a3cfcfa7d8d95962b3448ed886f3495a0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3cfcfa7d8d95962b3448ed886f3495a0">◆ </a></span>operator()() <span class="overload">[1/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter1 , class T_getter2 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1compose2__functor.html">compose2_functor</a>< T_setter, T_getter1, T_getter2 >::<a class="el" href="structsigc_1_1compose2__functor.html#a78ccb07f23696a452df9f61308885542">result_type</a> <a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor</a>< T_setter, T_getter1, T_getter2 >::operator()</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="adfcd11f81cefb39743d9467d21510c53"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#adfcd11f81cefb39743d9467d21510c53">◆ </a></span>operator()() <span class="overload">[2/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter1 , class T_getter2 > </div>
+<div class="memtemplate">
+template <class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1>::type <a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor</a>< T_setter, T_getter1, T_getter2 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a048e0ff176de0813c190279afd7e16dd"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a048e0ff176de0813c190279afd7e16dd">◆ </a></span>operator()() <span class="overload">[3/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter1 , class T_getter2 > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2>::type <a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor</a>< T_setter, T_getter1, T_getter2 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a48c102ded15a30326d7daefa8b817dd3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a48c102ded15a30326d7daefa8b817dd3">◆ </a></span>operator()() <span class="overload">[4/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter1 , class T_getter2 > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3>::type <a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor</a>< T_setter, T_getter1, T_getter2 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aaa7e4c7aae30b0585039655a71ed6850"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aaa7e4c7aae30b0585039655a71ed6850">◆ </a></span>operator()() <span class="overload">[5/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter1 , class T_getter2 > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4>::type <a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor</a>< T_setter, T_getter1, T_getter2 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="acb668cbfa312852668695eda2198c64b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#acb668cbfa312852668695eda2198c64b">◆ </a></span>operator()() <span class="overload">[6/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter1 , class T_getter2 > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type <a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor</a>< T_setter, T_getter1, T_getter2 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="af0cfb941c315a47381eaa288bfd87428"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af0cfb941c315a47381eaa288bfd87428">◆ </a></span>operator()() <span class="overload">[7/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter1 , class T_getter2 > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type <a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor</a>< T_setter, T_getter1, T_getter2 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg6 </td>
+ <td class="paramname"><em>_A_a6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="af39ab33c42d6e7c715b9f5e8ba4eb556"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af39ab33c42d6e7c715b9f5e8ba4eb556">◆ </a></span>operator()() <span class="overload">[8/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter1 , class T_getter2 > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type <a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor</a>< T_setter, T_getter1, T_getter2 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg6 </td>
+ <td class="paramname"><em>_A_a6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg7 </td>
+ <td class="paramname"><em>_A_a7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="af5404ffb509175690aa896932571e8bf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af5404ffb509175690aa896932571e8bf">◆ </a></span>get1_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter1 , class T_getter2 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1compose2__functor.html#ab7ab82eee45e8df9116a5a2b7c12c39c">getter1_type</a> <a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor</a>< T_setter, T_getter1, T_getter2 >::get1_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="af8404295ebbcb968a798c9fdf3f3d527"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af8404295ebbcb968a798c9fdf3f3d527">◆ </a></span>get2_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_setter , class T_getter1 , class T_getter2 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1compose2__functor.html#a75e252684d06f75f036043df56d8df69">getter2_type</a> <a class="el" href="structsigc_1_1compose2__functor.html">sigc::compose2_functor</a>< T_setter, T_getter1, T_getter2 >::get2_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::compose2_functor< T_setter, T_getter1, T_getter2 >" name="sigc::compose2_functor< T_setter, T_getter1, T_getter2 >">
+<area shape="rect" id="node1" title="Adaptor that combines three functors." alt="" coords="9,229,185,285"/>
+<area shape="rect" id="node2" href="$structsigc_1_1adapts.html" title=" " alt="" coords="5,155,188,181"/>
+<area shape="rect" id="node3" href="$structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="25,80,169,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="27,5,167,32"/>
+</map>
--- /dev/null
+20466b4f5fc430d3e4914f06ae220d28
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1connection.html">connection</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::connection Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1connection.html">sigc::connection</a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1connection.html#a581ae4f2b708cb6be7b081557864d6ec">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1connection.html">sigc::connection</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1connection.html#a7c86964aa4b0f339db5842e6c7e604f3">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1connection.html">sigc::connection</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1connection.html#a307b5df56439539be66f92d6e39f0bce">connected</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1connection.html">sigc::connection</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1connection.html#a95f80dbbf10fde0b851d78ec12cc2629">connection</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1connection.html">sigc::connection</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1connection.html#ad13d5e3331cc9b1494e0edb8fa37fdba">connection</a>(const connection & c)</td><td class="entry"><a class="el" href="structsigc_1_1connection.html">sigc::connection</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1connection.html#ac8847ae94e0b05bed6c81f54f58deef3">connection</a>(const slot_iterator< T_slot > & it)</td><td class="entry"><a class="el" href="structsigc_1_1connection.html">sigc::connection</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1connection.html#a124709de26781e5ffcf8bbb5dcd621ed">connection</a>(slot_base & sl)</td><td class="entry"><a class="el" href="structsigc_1_1connection.html">sigc::connection</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1connection.html#a0452bd182a61650d14a9664d6297ed1b">disconnect</a>()</td><td class="entry"><a class="el" href="structsigc_1_1connection.html">sigc::connection</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1connection.html#a810bdde9fbe7ad10bf9d578eebf929de">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1connection.html">sigc::connection</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1connection.html#ad45fe90d68fe295e76e130b070e97070">notify</a>(void * data)</td><td class="entry"><a class="el" href="structsigc_1_1connection.html">sigc::connection</a></td><td class="entry"><span class="mlabel">static</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1connection.html#a93215e1ea86c5fd0a465b2c4dba1257e">operator bool</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1connection.html">sigc::connection</a></td><td class="entry"><span class="mlabel">explicit</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1connection.html#a016094b53bafdc9ce593febb68cb00a5">operator=</a>(const connection & c)</td><td class="entry"><a class="el" href="structsigc_1_1connection.html">sigc::connection</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1connection.html#adee4ffd4b1669b4726fd9afc36330c14">operator=</a>(const slot_iterator< T_slot > & it)</td><td class="entry"><a class="el" href="structsigc_1_1connection.html">sigc::connection</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1connection.html#a15abcbfa76f1e5d8601cf4ad4176ed50">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1connection.html">sigc::connection</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1connection.html#a99678ccb2be5c20719f37e469416578a">~connection</a>()</td><td class="entry"><a class="el" href="structsigc_1_1connection.html">sigc::connection</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::connection Struct Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1connection.html">connection</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-static-methods">Static Public Member Functions</a> |
+<a href="structsigc_1_1connection-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::connection Struct Reference<div class="ingroups"><a class="el" href="group__signal.html">Signals</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Convinience class for safe disconnection.
+ <a href="structsigc_1_1connection.html#details">More...</a></p>
+
+<p><code>#include <sigc++/connection.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a95f80dbbf10fde0b851d78ec12cc2629"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1connection.html#a95f80dbbf10fde0b851d78ec12cc2629">connection</a> () noexcept</td></tr>
+<tr class="memdesc:a95f80dbbf10fde0b851d78ec12cc2629"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an empty connection object. <a href="structsigc_1_1connection.html#a95f80dbbf10fde0b851d78ec12cc2629">More...</a><br /></td></tr>
+<tr class="separator:a95f80dbbf10fde0b851d78ec12cc2629"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad13d5e3331cc9b1494e0edb8fa37fdba"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1connection.html#ad13d5e3331cc9b1494e0edb8fa37fdba">connection</a> (const <a class="el" href="structsigc_1_1connection.html">connection</a> & c)</td></tr>
+<tr class="memdesc:ad13d5e3331cc9b1494e0edb8fa37fdba"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a connection object copying an existing one. <a href="structsigc_1_1connection.html#ad13d5e3331cc9b1494e0edb8fa37fdba">More...</a><br /></td></tr>
+<tr class="separator:ad13d5e3331cc9b1494e0edb8fa37fdba"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8847ae94e0b05bed6c81f54f58deef3"><td class="memTemplParams" colspan="2">template<typename T_slot > </td></tr>
+<tr class="memitem:ac8847ae94e0b05bed6c81f54f58deef3"><td class="memTemplItemLeft" align="right" valign="top"> </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1connection.html#ac8847ae94e0b05bed6c81f54f58deef3">connection</a> (const <a class="el" href="structsigc_1_1slot__iterator.html">slot_iterator</a>< T_slot > & it)</td></tr>
+<tr class="memdesc:ac8847ae94e0b05bed6c81f54f58deef3"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a connection object from a slot list iterator. <a href="structsigc_1_1connection.html#ac8847ae94e0b05bed6c81f54f58deef3">More...</a><br /></td></tr>
+<tr class="separator:ac8847ae94e0b05bed6c81f54f58deef3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a124709de26781e5ffcf8bbb5dcd621ed"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1connection.html#a124709de26781e5ffcf8bbb5dcd621ed">connection</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & sl)</td></tr>
+<tr class="memdesc:a124709de26781e5ffcf8bbb5dcd621ed"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a connection object from a slot object. <a href="structsigc_1_1connection.html#a124709de26781e5ffcf8bbb5dcd621ed">More...</a><br /></td></tr>
+<tr class="separator:a124709de26781e5ffcf8bbb5dcd621ed"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a99678ccb2be5c20719f37e469416578a"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1connection.html#a99678ccb2be5c20719f37e469416578a">~connection</a> ()</td></tr>
+<tr class="separator:a99678ccb2be5c20719f37e469416578a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a581ae4f2b708cb6be7b081557864d6ec"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1connection.html#a581ae4f2b708cb6be7b081557864d6ec">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a581ae4f2b708cb6be7b081557864d6ec"><td class="mdescLeft"> </td><td class="mdescRight">Sets or unsets the blocking state of this connection. <a href="structsigc_1_1connection.html#a581ae4f2b708cb6be7b081557864d6ec">More...</a><br /></td></tr>
+<tr class="separator:a581ae4f2b708cb6be7b081557864d6ec"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7c86964aa4b0f339db5842e6c7e604f3"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1connection.html#a7c86964aa4b0f339db5842e6c7e604f3">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a7c86964aa4b0f339db5842e6c7e604f3"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the connection is blocked. <a href="structsigc_1_1connection.html#a7c86964aa4b0f339db5842e6c7e604f3">More...</a><br /></td></tr>
+<tr class="separator:a7c86964aa4b0f339db5842e6c7e604f3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a307b5df56439539be66f92d6e39f0bce"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1connection.html#a307b5df56439539be66f92d6e39f0bce">connected</a> () const noexcept</td></tr>
+<tr class="memdesc:a307b5df56439539be66f92d6e39f0bce"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the connection is still active. <a href="structsigc_1_1connection.html#a307b5df56439539be66f92d6e39f0bce">More...</a><br /></td></tr>
+<tr class="separator:a307b5df56439539be66f92d6e39f0bce"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0452bd182a61650d14a9664d6297ed1b"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1connection.html#a0452bd182a61650d14a9664d6297ed1b">disconnect</a> ()</td></tr>
+<tr class="memdesc:a0452bd182a61650d14a9664d6297ed1b"><td class="mdescLeft"> </td><td class="mdescRight">Disconnects the referred slot. <a href="structsigc_1_1connection.html#a0452bd182a61650d14a9664d6297ed1b">More...</a><br /></td></tr>
+<tr class="separator:a0452bd182a61650d14a9664d6297ed1b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a810bdde9fbe7ad10bf9d578eebf929de"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1connection.html#a810bdde9fbe7ad10bf9d578eebf929de">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a810bdde9fbe7ad10bf9d578eebf929de"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the connection is still active. <a href="structsigc_1_1connection.html#a810bdde9fbe7ad10bf9d578eebf929de">More...</a><br /></td></tr>
+<tr class="separator:a810bdde9fbe7ad10bf9d578eebf929de"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a93215e1ea86c5fd0a465b2c4dba1257e"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1connection.html#a93215e1ea86c5fd0a465b2c4dba1257e">operator bool</a> () noexcept</td></tr>
+<tr class="memdesc:a93215e1ea86c5fd0a465b2c4dba1257e"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the connection is still active. <a href="structsigc_1_1connection.html#a93215e1ea86c5fd0a465b2c4dba1257e">More...</a><br /></td></tr>
+<tr class="separator:a93215e1ea86c5fd0a465b2c4dba1257e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a016094b53bafdc9ce593febb68cb00a5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1connection.html">connection</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1connection.html#a016094b53bafdc9ce593febb68cb00a5">operator=</a> (const <a class="el" href="structsigc_1_1connection.html">connection</a> & c)</td></tr>
+<tr class="memdesc:a016094b53bafdc9ce593febb68cb00a5"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this connection object copying another one. <a href="structsigc_1_1connection.html#a016094b53bafdc9ce593febb68cb00a5">More...</a><br /></td></tr>
+<tr class="separator:a016094b53bafdc9ce593febb68cb00a5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adee4ffd4b1669b4726fd9afc36330c14"><td class="memTemplParams" colspan="2">template<typename T_slot > </td></tr>
+<tr class="memitem:adee4ffd4b1669b4726fd9afc36330c14"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1connection.html">connection</a> & </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1connection.html#adee4ffd4b1669b4726fd9afc36330c14">operator=</a> (const <a class="el" href="structsigc_1_1slot__iterator.html">slot_iterator</a>< T_slot > & it)</td></tr>
+<tr class="memdesc:adee4ffd4b1669b4726fd9afc36330c14"><td class="mdescLeft"> </td><td class="mdescRight">Overrides this connection object with another slot list iterator. <a href="structsigc_1_1connection.html#adee4ffd4b1669b4726fd9afc36330c14">More...</a><br /></td></tr>
+<tr class="separator:adee4ffd4b1669b4726fd9afc36330c14"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a15abcbfa76f1e5d8601cf4ad4176ed50"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1connection.html#a15abcbfa76f1e5d8601cf4ad4176ed50">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:a15abcbfa76f1e5d8601cf4ad4176ed50"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of this connection. <a href="structsigc_1_1connection.html#a15abcbfa76f1e5d8601cf4ad4176ed50">More...</a><br /></td></tr>
+<tr class="separator:a15abcbfa76f1e5d8601cf4ad4176ed50"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-static-methods"></a>
+Static Public Member Functions</h2></td></tr>
+<tr class="memitem:ad45fe90d68fe295e76e130b070e97070"><td class="memItemLeft" align="right" valign="top">static void * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1connection.html#ad45fe90d68fe295e76e130b070e97070">notify</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>)</td></tr>
+<tr class="memdesc:ad45fe90d68fe295e76e130b070e97070"><td class="mdescLeft"> </td><td class="mdescRight">Callback that is executed when the referred slot is destroyed. <a href="structsigc_1_1connection.html#ad45fe90d68fe295e76e130b070e97070">More...</a><br /></td></tr>
+<tr class="separator:ad45fe90d68fe295e76e130b070e97070"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><p>Convinience class for safe disconnection. </p>
+<p>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 (<a class="el" href="structsigc_1_1connection.html#a0452bd182a61650d14a9664d6297ed1b" title="Disconnects the referred slot.">disconnect()</a>). If the slot has already been destroyed, <a class="el" href="structsigc_1_1connection.html#a0452bd182a61650d14a9664d6297ed1b" title="Disconnects the referred slot.">disconnect()</a> does nothing. <a class="el" href="structsigc_1_1connection.html#a810bdde9fbe7ad10bf9d578eebf929de" title="Returns whether the connection is still active.">empty()</a> or operator bool() can be used to test whether the connection is still active. The connection can be blocked (<a class="el" href="structsigc_1_1connection.html#a581ae4f2b708cb6be7b081557864d6ec" title="Sets or unsets the blocking state of this connection.">block()</a>, <a class="el" href="structsigc_1_1connection.html#a15abcbfa76f1e5d8601cf4ad4176ed50" title="Unsets the blocking state of this connection.">unblock()</a>).</p>
+<p>This is possible because the connection object gets notified when the referred slot dies (<a class="el" href="structsigc_1_1connection.html#ad45fe90d68fe295e76e130b070e97070" title="Callback that is executed when the referred slot is destroyed.">notify()</a>). </p>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a95f80dbbf10fde0b851d78ec12cc2629"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a95f80dbbf10fde0b851d78ec12cc2629">◆ </a></span>connection() <span class="overload">[1/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">sigc::connection::connection </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">noexcept</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs an empty connection object. </p>
+
+</div>
+</div>
+<a id="ad13d5e3331cc9b1494e0edb8fa37fdba"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad13d5e3331cc9b1494e0edb8fa37fdba">◆ </a></span>connection() <span class="overload">[2/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname">sigc::connection::connection </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="structsigc_1_1connection.html">connection</a> & </td>
+ <td class="paramname"><em>c</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+<p>Constructs a connection object copying an existing one. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">c</td><td>The connection object to make a copy from. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="ac8847ae94e0b05bed6c81f54f58deef3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac8847ae94e0b05bed6c81f54f58deef3">◆ </a></span>connection() <span class="overload">[3/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">sigc::connection::connection </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="structsigc_1_1slot__iterator.html">slot_iterator</a>< T_slot > & </td>
+ <td class="paramname"><em>it</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a connection object from a slot list iterator. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">it</td><td>The slot list iterator to take the slot from. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a124709de26781e5ffcf8bbb5dcd621ed"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a124709de26781e5ffcf8bbb5dcd621ed">◆ </a></span>connection() <span class="overload">[4/4]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">sigc::connection::connection </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td>
+ <td class="paramname"><em>sl</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a connection object from a slot object. </p>
+<p>This is only useful if you create your own slot list. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">sl</td><td>The slot to operate on. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a99678ccb2be5c20719f37e469416578a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a99678ccb2be5c20719f37e469416578a">◆ </a></span>~connection()</h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname">sigc::connection::~connection </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a581ae4f2b708cb6be7b081557864d6ec"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a581ae4f2b708cb6be7b081557864d6ec">◆ </a></span>block()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">bool sigc::connection::block </td>
+ <td>(</td>
+ <td class="paramtype">bool </td>
+ <td class="paramname"><em>should_block</em> = <code>true</code></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">noexcept</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Sets or unsets the blocking state of this connection. </p>
+<p>See <a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9" title="Sets the blocking state.">slot_base::block()</a> for details. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">should_block</td><td>Indicates whether the blocking state should be set or unset. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd><code>true</code> if the connection has been in blocking state before. </dd></dl>
+
+</div>
+</div>
+<a id="a7c86964aa4b0f339db5842e6c7e604f3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7c86964aa4b0f339db5842e6c7e604f3">◆ </a></span>blocked()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">bool sigc::connection::blocked </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">noexcept</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Returns whether the connection is blocked. </p>
+<dl class="section return"><dt>Returns</dt><dd><code>true</code> if the connection is blocked. </dd></dl>
+
+</div>
+</div>
+<a id="a307b5df56439539be66f92d6e39f0bce"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a307b5df56439539be66f92d6e39f0bce">◆ </a></span>connected()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">bool sigc::connection::connected </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">noexcept</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Returns whether the connection is still active. </p>
+<dl class="section return"><dt>Returns</dt><dd><code>true</code> if the connection is still active. </dd></dl>
+
+</div>
+</div>
+<a id="a0452bd182a61650d14a9664d6297ed1b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0452bd182a61650d14a9664d6297ed1b">◆ </a></span>disconnect()</h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname">void sigc::connection::disconnect </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+<p>Disconnects the referred slot. </p>
+
+</div>
+</div>
+<a id="a810bdde9fbe7ad10bf9d578eebf929de"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a810bdde9fbe7ad10bf9d578eebf929de">◆ </a></span>empty()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">bool sigc::connection::empty </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">noexcept</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Returns whether the connection is still active. </p>
+<dl class="section return"><dt>Returns</dt><dd><code>false</code> if the connection is still active. </dd></dl>
+
+</div>
+</div>
+<a id="ad45fe90d68fe295e76e130b070e97070"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad45fe90d68fe295e76e130b070e97070">◆ </a></span>notify()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">static void* sigc::connection::notify </td>
+ <td>(</td>
+ <td class="paramtype">void * </td>
+ <td class="paramname"><em>data</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">static</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Callback that is executed when the referred slot is destroyed. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">data</td><td>The connection object notified (<code>this</code>). </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a93215e1ea86c5fd0a465b2c4dba1257e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a93215e1ea86c5fd0a465b2c4dba1257e">◆ </a></span>operator bool()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">sigc::connection::operator bool </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">explicit</span><span class="mlabel">noexcept</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Returns whether the connection is still active. </p>
+<dl class="section return"><dt>Returns</dt><dd><code>true</code> if the connection is still active. </dd></dl>
+
+</div>
+</div>
+<a id="a016094b53bafdc9ce593febb68cb00a5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a016094b53bafdc9ce593febb68cb00a5">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1connection.html">connection</a>& sigc::connection::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="structsigc_1_1connection.html">connection</a> & </td>
+ <td class="paramname"><em>c</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+<p>Overrides this connection object copying another one. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">c</td><td>The connection object to make a copy from. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="adee4ffd4b1669b4726fd9afc36330c14"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#adee4ffd4b1669b4726fd9afc36330c14">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1connection.html">connection</a>& sigc::connection::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="structsigc_1_1slot__iterator.html">slot_iterator</a>< T_slot > & </td>
+ <td class="paramname"><em>it</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Overrides this connection object with another slot list iterator. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">it</td><td>The new slot list iterator to take the slot from. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="a15abcbfa76f1e5d8601cf4ad4176ed50"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a15abcbfa76f1e5d8601cf4ad4176ed50">◆ </a></span>unblock()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">bool sigc::connection::unblock </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">noexcept</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Unsets the blocking state of this connection. </p>
+<dl class="section return"><dt>Returns</dt><dd><code>true</code> if the connection has been in blocking state before. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1const__reference__wrapper.html">const_reference_wrapper</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::const_reference_wrapper< T_type > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1const__reference__wrapper.html">sigc::const_reference_wrapper< T_type ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1const__reference__wrapper.html#a249ae888fb9be126598d81ce339fbf81">const_reference_wrapper</a>(const T_type & v)</td><td class="entry"><a class="el" href="structsigc_1_1const__reference__wrapper.html">sigc::const_reference_wrapper< T_type ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1const__reference__wrapper.html#a2cf7a981855668dfb69e98cfaa6eb779">operator const T_type &</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1const__reference__wrapper.html">sigc::const_reference_wrapper< T_type ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1const__reference__wrapper.html#aaaba3da60073e485144be648f8c4f69f">value_</a></td><td class="entry"><a class="el" href="structsigc_1_1const__reference__wrapper.html">sigc::const_reference_wrapper< T_type ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::const_reference_wrapper< T_type > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1const__reference__wrapper.html">const_reference_wrapper</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="structsigc_1_1const__reference__wrapper-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::const_reference_wrapper< T_type > Struct Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Const reference wrapper.
+ <a href="structsigc_1_1const__reference__wrapper.html#details">More...</a></p>
+
+<p><code>#include <sigc++/reference_wrapper.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a249ae888fb9be126598d81ce339fbf81"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1const__reference__wrapper.html#a249ae888fb9be126598d81ce339fbf81">const_reference_wrapper</a> (const T_type & v)</td></tr>
+<tr class="separator:a249ae888fb9be126598d81ce339fbf81"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2cf7a981855668dfb69e98cfaa6eb779"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1const__reference__wrapper.html#a2cf7a981855668dfb69e98cfaa6eb779">operator const T_type &</a> () const</td></tr>
+<tr class="separator:a2cf7a981855668dfb69e98cfaa6eb779"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:aaaba3da60073e485144be648f8c4f69f"><td class="memItemLeft" align="right" valign="top">const T_type & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1const__reference__wrapper.html#aaaba3da60073e485144be648f8c4f69f">value_</a></td></tr>
+<tr class="separator:aaaba3da60073e485144be648f8c4f69f"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_type><br />
+struct sigc::const_reference_wrapper< T_type ></h3>
+
+<p>Const reference wrapper. </p>
+<p>Use <a class="el" href="namespacesigc.html#a48e982c74c057b5630246ba436524041" title="Creates a reference wrapper.">sigc::ref()</a> to create a const reference wrapper.</p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000203">Deprecated:</a></b></dt><dd>Use std::ref() or std::cref() instead to create a <a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a03225.html">std::reference_wrapper()</a>. </dd></dl>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a249ae888fb9be126598d81ce339fbf81"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a249ae888fb9be126598d81ce339fbf81">◆ </a></span>const_reference_wrapper()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1const__reference__wrapper.html">sigc::const_reference_wrapper</a>< T_type >::<a class="el" href="structsigc_1_1const__reference__wrapper.html">const_reference_wrapper</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_type & </td>
+ <td class="paramname"><em>v</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a2cf7a981855668dfb69e98cfaa6eb779"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2cf7a981855668dfb69e98cfaa6eb779">◆ </a></span>operator const T_type &()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1const__reference__wrapper.html">sigc::const_reference_wrapper</a>< T_type >::operator const T_type & </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="aaaba3da60073e485144be648f8c4f69f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aaaba3da60073e485144be648f8c4f69f">◆ </a></span>value_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">const T_type& <a class="el" href="structsigc_1_1const__reference__wrapper.html">sigc::const_reference_wrapper</a>< T_type >::value_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::deduce_result_type< T_functor, T_args > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1deduce__result__type.html">sigc::deduce_result_type< T_functor, T_args ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1deduce__result__type.html#a46816d343f0924170208d220b7e599f4">test</a>()</td><td class="entry"><a class="el" href="structsigc_1_1deduce__result__type.html">sigc::deduce_result_type< T_functor, T_args ></a></td><td class="entry"><span class="mlabel">static</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1deduce__result__type.html#ab9356fdb52cf08ca8eded48bae5e5bdb">test</a>()</td><td class="entry"><a class="el" href="structsigc_1_1deduce__result__type.html">sigc::deduce_result_type< T_functor, T_args ></a></td><td class="entry"><span class="mlabel">static</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1deduce__result__type.html#a529a6b7809ea3ad1a2d4392b9ffcec42">type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1deduce__result__type.html">sigc::deduce_result_type< T_functor, T_args ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::deduce_result_type< T_functor, T_args > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-static-methods">Static Public Member Functions</a> |
+<a href="structsigc_1_1deduce__result__type-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::deduce_result_type< T_functor, T_args > Struct Template Reference<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Deduce the return type of a functor.
+ <a href="structsigc_1_1deduce__result__type.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/deduce_result_type.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a529a6b7809ea3ad1a2d4392b9ffcec42"><td class="memItemLeft" align="right" valign="top">using </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1deduce__result__type.html#a529a6b7809ea3ad1a2d4392b9ffcec42">type</a> = decltype(<a class="el" href="structsigc_1_1deduce__result__type.html#a46816d343f0924170208d220b7e599f4">test</a>< T_functor >())</td></tr>
+<tr class="separator:a529a6b7809ea3ad1a2d4392b9ffcec42"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-static-methods"></a>
+Static Public Member Functions</h2></td></tr>
+<tr class="memitem:a46816d343f0924170208d220b7e599f4"><td class="memTemplParams" colspan="2">template<class U_functor , typename = typename std::is_base_of<adaptor_base, T_functor>::type> </td></tr>
+<tr class="memitem:a46816d343f0924170208d220b7e599f4"><td class="memTemplItemLeft" align="right" valign="top">static U_functor::template <a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_args... >::<a class="el" href="structsigc_1_1deduce__result__type.html#a529a6b7809ea3ad1a2d4392b9ffcec42">type</a> </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1deduce__result__type.html#a46816d343f0924170208d220b7e599f4">test</a> ()</td></tr>
+<tr class="separator:a46816d343f0924170208d220b7e599f4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab9356fdb52cf08ca8eded48bae5e5bdb"><td class="memTemplParams" colspan="2">template<class U_functor > </td></tr>
+<tr class="memitem:ab9356fdb52cf08ca8eded48bae5e5bdb"><td class="memTemplItemLeft" align="right" valign="top">static <a class="el" href="structsigc_1_1functor__trait.html">functor_trait</a>< T_functor >::result_type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1deduce__result__type.html#ab9356fdb52cf08ca8eded48bae5e5bdb">test</a> ()</td></tr>
+<tr class="separator:ab9356fdb52cf08ca8eded48bae5e5bdb"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_functor, class... T_args><br />
+struct sigc::deduce_result_type< T_functor, T_args ></h3>
+
+<p>Deduce the return type of a functor. </p>
+<p><code>typename <a class="el" href="structsigc_1_1deduce__result__type.html#a529a6b7809ea3ad1a2d4392b9ffcec42">deduce_result_type<functor_type, list of arg_types>::type</a></code> deduces a functor's result type if <code>functor_type</code> inherits from <a class="el" href="structsigc_1_1functor__base.html" title="A hint to the compiler.">sigc::functor_base</a> and defines <code>result_type</code> or if <code>functor_type</code> is actually a (member) function type. Multi-type functors are not supported.</p>
+<p>sigc++ adaptors use <code>typename <a class="el" href="structsigc_1_1deduce__result__type.html#a529a6b7809ea3ad1a2d4392b9ffcec42">deduce_result_type<functor_type, list of arg_types>::type</a></code> to determine the return type of their <code>templated operator()</code> overloads.</p>
+<p>Adaptors in turn define a nested template class <code><a class="el" href="structsigc_1_1deduce__result__type.html" title="Deduce the return type of a functor.">deduce_result_type</a></code> that is used by template specializations of the global <a class="el" href="structsigc_1_1deduce__result__type.html" title="Deduce the return type of a functor.">deduce_result_type</a> template to correctly deduce the return types of the adaptor's suitable <code>template operator()</code> overload. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a529a6b7809ea3ad1a2d4392b9ffcec42"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a529a6b7809ea3ad1a2d4392b9ffcec42">◆ </a></span>type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class... T_args> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">using <a class="el" href="structsigc_1_1deduce__result__type.html">sigc::deduce_result_type</a>< T_functor, T_args >::<a class="el" href="structsigc_1_1deduce__result__type.html#a529a6b7809ea3ad1a2d4392b9ffcec42">type</a> = decltype (<a class="el" href="structsigc_1_1deduce__result__type.html#a46816d343f0924170208d220b7e599f4">test</a><T_functor> ())</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a46816d343f0924170208d220b7e599f4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a46816d343f0924170208d220b7e599f4">◆ </a></span>test() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class... T_args> </div>
+<div class="memtemplate">
+template <class U_functor , typename = typename std::is_base_of<adaptor_base, T_functor>::type> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">static U_functor::template <a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_args...>::<a class="el" href="structsigc_1_1deduce__result__type.html#a529a6b7809ea3ad1a2d4392b9ffcec42">type</a> <a class="el" href="structsigc_1_1deduce__result__type.html">sigc::deduce_result_type</a>< T_functor, T_args >::test </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">static</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ab9356fdb52cf08ca8eded48bae5e5bdb"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab9356fdb52cf08ca8eded48bae5e5bdb">◆ </a></span>test() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class... T_args> </div>
+<div class="memtemplate">
+template <class U_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">static <a class="el" href="structsigc_1_1functor__trait.html">functor_trait</a><T_functor>::result_type <a class="el" href="structsigc_1_1deduce__result__type.html">sigc::deduce_result_type</a>< T_functor, T_args >::test </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">static</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1exception__catch__functor.html">exception_catch_functor</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::exception_catch_functor< T_functor, T_catcher, T_return > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor< T_functor, T_catcher, T_return ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor.html#a5dc4ecab205c7ad5c3954c2572d4cc08">adaptor_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor< T_functor, T_catcher, T_return ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a>(const T_functor & _A_functor)</td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor.html#af94123d76a61a13258893ed575a019b0">catcher_</a></td><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor< T_functor, T_catcher, T_return ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor.html#acefeea54e1d83cb64844a956598918fd">exception_catch_functor</a>(const T_functor & _A_func, const T_catcher & _A_catcher)</td><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor< T_functor, T_catcher, T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor.html#a9f6b5068be1af2623e2aef727f2b73db">operator()</a>()</td><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor< T_functor, T_catcher, T_return ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor.html#a5472e0c6cdc3e9f0994bcd6676e7ed0f">operator()</a>(T_arg1 _A_a1)</td><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor< T_functor, T_catcher, T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor.html#a00ce284a875f728da4db0b401f40c561">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2)</td><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor< T_functor, T_catcher, T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor.html#aa20b567a833cdc29517f4161be5bb8b2">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)</td><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor< T_functor, T_catcher, T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor.html#a5bb82bbe1b0491cd5c53680eb5cd6b03">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)</td><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor< T_functor, T_catcher, T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor.html#aae43815dd495f34d8d519fb2dcf26102">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)</td><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor< T_functor, T_catcher, T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor.html#abc125711f5e27d38b3762e18069289ff">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)</td><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor< T_functor, T_catcher, T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor.html#a07ae1354aa93e8421c705a21cbb85ad8">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)</td><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor< T_functor, T_catcher, T_return ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor.html#a498f5575ae283594cfe03288fab54fdf">result_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor< T_functor, T_catcher, T_return ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::exception_catch_functor< T_functor, T_catcher, T_return > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1exception__catch__functor.html">exception_catch_functor</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="structsigc_1_1exception__catch__functor-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::exception_catch_functor< T_functor, T_catcher, T_return > Struct Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><code>#include <sigc++/adaptors/exception_catch.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::exception_catch_functor< T_functor, T_catcher, T_return >:</div>
+<div class="dyncontent">
+<div class="center"><img src="structsigc_1_1exception__catch__functor__inherit__graph.png" border="0" usemap="#asigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01T__return_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01T__return_01_4_inherit__map" id="asigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01T__return_01_4_inherit__map">
+<area shape="rect" title=" " alt="" coords="17,229,184,285"/>
+<area shape="rect" href="structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="5,155,196,181"/>
+<area shape="rect" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="29,80,173,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="31,5,171,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a5dc4ecab205c7ad5c3954c2572d4cc08"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adapts.html">adapts</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1exception__catch__functor.html#a5dc4ecab205c7ad5c3954c2572d4cc08">adaptor_type</a></td></tr>
+<tr class="separator:a5dc4ecab205c7ad5c3954c2572d4cc08"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a498f5575ae283594cfe03288fab54fdf"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1exception__catch__functor.html#a498f5575ae283594cfe03288fab54fdf">result_type</a></td></tr>
+<tr class="separator:a498f5575ae283594cfe03288fab54fdf"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td></tr>
+<tr class="separator:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td></tr>
+<tr class="separator:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:acefeea54e1d83cb64844a956598918fd"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1exception__catch__functor.html#acefeea54e1d83cb64844a956598918fd">exception_catch_functor</a> (const T_functor & _A_func, const T_catcher & _A_catcher)</td></tr>
+<tr class="separator:acefeea54e1d83cb64844a956598918fd"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f6b5068be1af2623e2aef727f2b73db"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1exception__catch__functor.html#a9f6b5068be1af2623e2aef727f2b73db">operator()</a> ()</td></tr>
+<tr class="separator:a9f6b5068be1af2623e2aef727f2b73db"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5472e0c6cdc3e9f0994bcd6676e7ed0f"><td class="memTemplParams" colspan="2">template<class T_arg1 > </td></tr>
+<tr class="memitem:a5472e0c6cdc3e9f0994bcd6676e7ed0f"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1exception__catch__functor.html#a5472e0c6cdc3e9f0994bcd6676e7ed0f">operator()</a> (T_arg1 _A_a1)</td></tr>
+<tr class="separator:a5472e0c6cdc3e9f0994bcd6676e7ed0f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a00ce284a875f728da4db0b401f40c561"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:a00ce284a875f728da4db0b401f40c561"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1exception__catch__functor.html#a00ce284a875f728da4db0b401f40c561">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2)</td></tr>
+<tr class="separator:a00ce284a875f728da4db0b401f40c561"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa20b567a833cdc29517f4161be5bb8b2"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:aa20b567a833cdc29517f4161be5bb8b2"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1exception__catch__functor.html#aa20b567a833cdc29517f4161be5bb8b2">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)</td></tr>
+<tr class="separator:aa20b567a833cdc29517f4161be5bb8b2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5bb82bbe1b0491cd5c53680eb5cd6b03"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:a5bb82bbe1b0491cd5c53680eb5cd6b03"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1exception__catch__functor.html#a5bb82bbe1b0491cd5c53680eb5cd6b03">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)</td></tr>
+<tr class="separator:a5bb82bbe1b0491cd5c53680eb5cd6b03"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aae43815dd495f34d8d519fb2dcf26102"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:aae43815dd495f34d8d519fb2dcf26102"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1exception__catch__functor.html#aae43815dd495f34d8d519fb2dcf26102">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)</td></tr>
+<tr class="separator:aae43815dd495f34d8d519fb2dcf26102"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abc125711f5e27d38b3762e18069289ff"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:abc125711f5e27d38b3762e18069289ff"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1exception__catch__functor.html#abc125711f5e27d38b3762e18069289ff">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)</td></tr>
+<tr class="separator:abc125711f5e27d38b3762e18069289ff"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a07ae1354aa93e8421c705a21cbb85ad8"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:a07ae1354aa93e8421c705a21cbb85ad8"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1exception__catch__functor.html#a07ae1354aa93e8421c705a21cbb85ad8">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)</td></tr>
+<tr class="separator:a07ae1354aa93e8421c705a21cbb85ad8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a> (const T_functor & _A_functor)</td></tr>
+<tr class="memdesc:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an adaptor that wraps the passed functor. <a href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">More...</a><br /></td></tr>
+<tr class="separator:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:af94123d76a61a13258893ed575a019b0"><td class="memItemLeft" align="right" valign="top">T_catcher </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1exception__catch__functor.html#af94123d76a61a13258893ed575a019b0">catcher_</a></td></tr>
+<tr class="separator:af94123d76a61a13258893ed575a019b0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_attribs_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td></tr>
+<tr class="memdesc:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that is invoked from operator()(). <a href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">More...</a><br /></td></tr>
+<tr class="separator:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a5dc4ecab205c7ad5c3954c2572d4cc08"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5dc4ecab205c7ad5c3954c2572d4cc08">◆ </a></span>adaptor_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_catcher , class T_return = typename adapts<T_functor>::result_type> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1adapts.html">adapts</a><T_functor>::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> <a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor</a>< T_functor, T_catcher, T_return >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a498f5575ae283594cfe03288fab54fdf"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a498f5575ae283594cfe03288fab54fdf">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_catcher , class T_return = typename adapts<T_functor>::result_type> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor</a>< T_functor, T_catcher, T_return >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="acefeea54e1d83cb64844a956598918fd"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#acefeea54e1d83cb64844a956598918fd">◆ </a></span>exception_catch_functor()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_catcher , class T_return = typename adapts<T_functor>::result_type> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor</a>< T_functor, T_catcher, T_return >::<a class="el" href="structsigc_1_1exception__catch__functor.html">exception_catch_functor</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_catcher & </td>
+ <td class="paramname"><em>_A_catcher</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a9f6b5068be1af2623e2aef727f2b73db"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9f6b5068be1af2623e2aef727f2b73db">◆ </a></span>operator()() <span class="overload">[1/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_catcher , class T_return > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1exception__catch__functor.html">exception_catch_functor</a>< T_functor, T_catcher, T_return >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> <a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor</a>< T_functor, T_catcher, T_return >::operator()</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a5472e0c6cdc3e9f0994bcd6676e7ed0f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5472e0c6cdc3e9f0994bcd6676e7ed0f">◆ </a></span>operator()() <span class="overload">[2/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_catcher , class T_return = typename adapts<T_functor>::result_type> </div>
+<div class="memtemplate">
+template <class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1>::type <a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor</a>< T_functor, T_catcher, T_return >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a00ce284a875f728da4db0b401f40c561"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a00ce284a875f728da4db0b401f40c561">◆ </a></span>operator()() <span class="overload">[3/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_catcher , class T_return = typename adapts<T_functor>::result_type> </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2>::type <a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor</a>< T_functor, T_catcher, T_return >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aa20b567a833cdc29517f4161be5bb8b2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa20b567a833cdc29517f4161be5bb8b2">◆ </a></span>operator()() <span class="overload">[4/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_catcher , class T_return = typename adapts<T_functor>::result_type> </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3>::type <a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor</a>< T_functor, T_catcher, T_return >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a5bb82bbe1b0491cd5c53680eb5cd6b03"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5bb82bbe1b0491cd5c53680eb5cd6b03">◆ </a></span>operator()() <span class="overload">[5/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_catcher , class T_return = typename adapts<T_functor>::result_type> </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4>::type <a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor</a>< T_functor, T_catcher, T_return >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aae43815dd495f34d8d519fb2dcf26102"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aae43815dd495f34d8d519fb2dcf26102">◆ </a></span>operator()() <span class="overload">[6/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_catcher , class T_return = typename adapts<T_functor>::result_type> </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type <a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor</a>< T_functor, T_catcher, T_return >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="abc125711f5e27d38b3762e18069289ff"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abc125711f5e27d38b3762e18069289ff">◆ </a></span>operator()() <span class="overload">[7/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_catcher , class T_return = typename adapts<T_functor>::result_type> </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type <a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor</a>< T_functor, T_catcher, T_return >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg6 </td>
+ <td class="paramname"><em>_A_a6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a07ae1354aa93e8421c705a21cbb85ad8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a07ae1354aa93e8421c705a21cbb85ad8">◆ </a></span>operator()() <span class="overload">[8/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_catcher , class T_return = typename adapts<T_functor>::result_type> </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type <a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor</a>< T_functor, T_catcher, T_return >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg6 </td>
+ <td class="paramname"><em>_A_a6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg7 </td>
+ <td class="paramname"><em>_A_a7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="af94123d76a61a13258893ed575a019b0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af94123d76a61a13258893ed575a019b0">◆ </a></span>catcher_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_catcher , class T_return = typename adapts<T_functor>::result_type> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">T_catcher <a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor</a>< T_functor, T_catcher, T_return >::catcher_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html">exception_catch_functor< T_functor, T_catcher, void ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::exception_catch_functor< T_functor, T_catcher, void > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html">sigc::exception_catch_functor< T_functor, T_catcher, void ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#aa9803c7bd355ae0674dbfabf346676c0">adaptor_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html">sigc::exception_catch_functor< T_functor, T_catcher, void ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a>(const T_functor & _A_functor)</td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#acc50467493545db2b55e638f7ac28c42">catcher_</a></td><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html">sigc::exception_catch_functor< T_functor, T_catcher, void ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a84b167dc0dd520253776c55eb711c461">exception_catch_functor</a>()</td><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html">sigc::exception_catch_functor< T_functor, T_catcher, void ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a08a5ce7a94a0646e92c5eb8fb6b7d5f3">exception_catch_functor</a>(const T_functor & _A_func, const T_catcher & _A_catcher)</td><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html">sigc::exception_catch_functor< T_functor, T_catcher, void ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a24e842daf8e8d756e2b77ceb47c55c14">operator()</a>()</td><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html">sigc::exception_catch_functor< T_functor, T_catcher, void ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#ade12d3049fdb07307d0852aa9a90f1b6">operator()</a>(T_arg1 _A_a1)</td><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html">sigc::exception_catch_functor< T_functor, T_catcher, void ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a552ee97ff7ee248d75ecd0241d379d31">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2)</td><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html">sigc::exception_catch_functor< T_functor, T_catcher, void ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a4062190405963d2bf806219d3480b2dd">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)</td><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html">sigc::exception_catch_functor< T_functor, T_catcher, void ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a68bec561e3c051fc3551965ccbad4398">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)</td><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html">sigc::exception_catch_functor< T_functor, T_catcher, void ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a1eb6fb5783d65d904474f6ffe14ace7b">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)</td><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html">sigc::exception_catch_functor< T_functor, T_catcher, void ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a4c24ffa31304c0647b0d29cba07ffe3a">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)</td><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html">sigc::exception_catch_functor< T_functor, T_catcher, void ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#ab4d0d68e2dd1d356ff932ac2ca846a0c">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)</td><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html">sigc::exception_catch_functor< T_functor, T_catcher, void ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a06506e0d4da26682740b7f4f9aec80d5">result_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html">sigc::exception_catch_functor< T_functor, T_catcher, void ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a1537e7d0175046d65522bd960149bb62">~exception_catch_functor</a>()</td><td class="entry"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html">sigc::exception_catch_functor< T_functor, T_catcher, void ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::exception_catch_functor< T_functor, T_catcher, void > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html">exception_catch_functor< T_functor, T_catcher, void ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::exception_catch_functor< T_functor, T_catcher, void > Struct Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><code>#include <sigc++/adaptors/exception_catch.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::exception_catch_functor< T_functor, T_catcher, void >:</div>
+<div class="dyncontent">
+<div class="center"><img src="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4__inherit__graph.png" border="0" usemap="#asigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4_inherit__map" id="asigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4_inherit__map">
+<area shape="rect" title=" " alt="" coords="19,229,182,285"/>
+<area shape="rect" href="structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="5,155,196,181"/>
+<area shape="rect" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="29,80,173,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="31,5,171,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:aa9803c7bd355ae0674dbfabf346676c0"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adapts.html">adapts</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#aa9803c7bd355ae0674dbfabf346676c0">adaptor_type</a></td></tr>
+<tr class="separator:aa9803c7bd355ae0674dbfabf346676c0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a06506e0d4da26682740b7f4f9aec80d5"><td class="memItemLeft" align="right" valign="top">typedef void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a06506e0d4da26682740b7f4f9aec80d5">result_type</a></td></tr>
+<tr class="separator:a06506e0d4da26682740b7f4f9aec80d5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td></tr>
+<tr class="separator:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td></tr>
+<tr class="separator:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a84b167dc0dd520253776c55eb711c461"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a84b167dc0dd520253776c55eb711c461">exception_catch_functor</a> ()</td></tr>
+<tr class="separator:a84b167dc0dd520253776c55eb711c461"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a08a5ce7a94a0646e92c5eb8fb6b7d5f3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a08a5ce7a94a0646e92c5eb8fb6b7d5f3">exception_catch_functor</a> (const T_functor & _A_func, const T_catcher & _A_catcher)</td></tr>
+<tr class="separator:a08a5ce7a94a0646e92c5eb8fb6b7d5f3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1537e7d0175046d65522bd960149bb62"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a1537e7d0175046d65522bd960149bb62">~exception_catch_functor</a> ()</td></tr>
+<tr class="separator:a1537e7d0175046d65522bd960149bb62"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e842daf8e8d756e2b77ceb47c55c14"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a24e842daf8e8d756e2b77ceb47c55c14">operator()</a> ()</td></tr>
+<tr class="separator:a24e842daf8e8d756e2b77ceb47c55c14"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ade12d3049fdb07307d0852aa9a90f1b6"><td class="memTemplParams" colspan="2">template<class T_arg1 > </td></tr>
+<tr class="memitem:ade12d3049fdb07307d0852aa9a90f1b6"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#ade12d3049fdb07307d0852aa9a90f1b6">operator()</a> (T_arg1 _A_a1)</td></tr>
+<tr class="separator:ade12d3049fdb07307d0852aa9a90f1b6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a552ee97ff7ee248d75ecd0241d379d31"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:a552ee97ff7ee248d75ecd0241d379d31"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a552ee97ff7ee248d75ecd0241d379d31">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2)</td></tr>
+<tr class="separator:a552ee97ff7ee248d75ecd0241d379d31"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4062190405963d2bf806219d3480b2dd"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:a4062190405963d2bf806219d3480b2dd"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a4062190405963d2bf806219d3480b2dd">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)</td></tr>
+<tr class="separator:a4062190405963d2bf806219d3480b2dd"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a68bec561e3c051fc3551965ccbad4398"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:a68bec561e3c051fc3551965ccbad4398"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a68bec561e3c051fc3551965ccbad4398">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)</td></tr>
+<tr class="separator:a68bec561e3c051fc3551965ccbad4398"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1eb6fb5783d65d904474f6ffe14ace7b"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:a1eb6fb5783d65d904474f6ffe14ace7b"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a1eb6fb5783d65d904474f6ffe14ace7b">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)</td></tr>
+<tr class="separator:a1eb6fb5783d65d904474f6ffe14ace7b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4c24ffa31304c0647b0d29cba07ffe3a"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:a4c24ffa31304c0647b0d29cba07ffe3a"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a4c24ffa31304c0647b0d29cba07ffe3a">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)</td></tr>
+<tr class="separator:a4c24ffa31304c0647b0d29cba07ffe3a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab4d0d68e2dd1d356ff932ac2ca846a0c"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:ab4d0d68e2dd1d356ff932ac2ca846a0c"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#ab4d0d68e2dd1d356ff932ac2ca846a0c">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)</td></tr>
+<tr class="separator:ab4d0d68e2dd1d356ff932ac2ca846a0c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a> (const T_functor & _A_functor)</td></tr>
+<tr class="memdesc:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an adaptor that wraps the passed functor. <a href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">More...</a><br /></td></tr>
+<tr class="separator:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:acc50467493545db2b55e638f7ac28c42"><td class="memItemLeft" align="right" valign="top">T_catcher </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#acc50467493545db2b55e638f7ac28c42">catcher_</a></td></tr>
+<tr class="separator:acc50467493545db2b55e638f7ac28c42"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_attribs_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td></tr>
+<tr class="memdesc:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that is invoked from operator()(). <a href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">More...</a><br /></td></tr>
+<tr class="separator:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="aa9803c7bd355ae0674dbfabf346676c0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa9803c7bd355ae0674dbfabf346676c0">◆ </a></span>adaptor_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_catcher > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1adapts.html">adapts</a><T_functor>::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> <a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor</a>< T_functor, T_catcher, void >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a06506e0d4da26682740b7f4f9aec80d5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a06506e0d4da26682740b7f4f9aec80d5">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_catcher > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef void <a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor</a>< T_functor, T_catcher, void >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a84b167dc0dd520253776c55eb711c461"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a84b167dc0dd520253776c55eb711c461">◆ </a></span>exception_catch_functor() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_catcher > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor</a>< T_functor, T_catcher, void >::<a class="el" href="structsigc_1_1exception__catch__functor.html">exception_catch_functor</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a08a5ce7a94a0646e92c5eb8fb6b7d5f3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a08a5ce7a94a0646e92c5eb8fb6b7d5f3">◆ </a></span>exception_catch_functor() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_catcher > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor</a>< T_functor, T_catcher, void >::<a class="el" href="structsigc_1_1exception__catch__functor.html">exception_catch_functor</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_catcher & </td>
+ <td class="paramname"><em>_A_catcher</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a1537e7d0175046d65522bd960149bb62"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1537e7d0175046d65522bd960149bb62">◆ </a></span>~exception_catch_functor()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_catcher > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor</a>< T_functor, T_catcher, void >::~<a class="el" href="structsigc_1_1exception__catch__functor.html">exception_catch_functor</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a24e842daf8e8d756e2b77ceb47c55c14"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a24e842daf8e8d756e2b77ceb47c55c14">◆ </a></span>operator()() <span class="overload">[1/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_catcher > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">void <a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor</a>< T_functor, T_catcher, void >::operator()</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ade12d3049fdb07307d0852aa9a90f1b6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ade12d3049fdb07307d0852aa9a90f1b6">◆ </a></span>operator()() <span class="overload">[2/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_catcher > </div>
+<div class="memtemplate">
+template <class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1>::type <a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor</a>< T_functor, T_catcher, void >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a552ee97ff7ee248d75ecd0241d379d31"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a552ee97ff7ee248d75ecd0241d379d31">◆ </a></span>operator()() <span class="overload">[3/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_catcher > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2>::type <a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor</a>< T_functor, T_catcher, void >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a4062190405963d2bf806219d3480b2dd"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4062190405963d2bf806219d3480b2dd">◆ </a></span>operator()() <span class="overload">[4/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_catcher > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3>::type <a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor</a>< T_functor, T_catcher, void >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a68bec561e3c051fc3551965ccbad4398"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a68bec561e3c051fc3551965ccbad4398">◆ </a></span>operator()() <span class="overload">[5/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_catcher > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4>::type <a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor</a>< T_functor, T_catcher, void >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a1eb6fb5783d65d904474f6ffe14ace7b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1eb6fb5783d65d904474f6ffe14ace7b">◆ </a></span>operator()() <span class="overload">[6/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_catcher > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type <a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor</a>< T_functor, T_catcher, void >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a4c24ffa31304c0647b0d29cba07ffe3a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4c24ffa31304c0647b0d29cba07ffe3a">◆ </a></span>operator()() <span class="overload">[7/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_catcher > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type <a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor</a>< T_functor, T_catcher, void >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg6 </td>
+ <td class="paramname"><em>_A_a6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ab4d0d68e2dd1d356ff932ac2ca846a0c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab4d0d68e2dd1d356ff932ac2ca846a0c">◆ </a></span>operator()() <span class="overload">[8/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_catcher > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type <a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor</a>< T_functor, T_catcher, void >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg6 </td>
+ <td class="paramname"><em>_A_a6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg7 </td>
+ <td class="paramname"><em>_A_a7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="acc50467493545db2b55e638f7ac28c42"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#acc50467493545db2b55e638f7ac28c42">◆ </a></span>catcher_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_catcher > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">T_catcher <a class="el" href="structsigc_1_1exception__catch__functor.html">sigc::exception_catch_functor</a>< T_functor, T_catcher, void >::catcher_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::exception_catch_functor< T_functor, T_catcher, void >" name="sigc::exception_catch_functor< T_functor, T_catcher, void >">
+<area shape="rect" id="node1" title=" " alt="" coords="19,229,182,285"/>
+<area shape="rect" id="node2" href="$structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="5,155,196,181"/>
+<area shape="rect" id="node3" href="$structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="29,80,173,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="31,5,171,32"/>
+</map>
--- /dev/null
+60c7e2a6d441472c2b38bde3bd085911
\ No newline at end of file
--- /dev/null
+<map id="sigc::exception_catch_functor< T_functor, T_catcher, T_return >" name="sigc::exception_catch_functor< T_functor, T_catcher, T_return >">
+<area shape="rect" id="node1" title=" " alt="" coords="17,229,184,285"/>
+<area shape="rect" id="node2" href="$structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="5,155,196,181"/>
+<area shape="rect" id="node3" href="$structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="29,80,173,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="31,5,171,32"/>
+</map>
--- /dev/null
+f42623956d39a6e6a18b5a4f87a259b5
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::functor_base Struct Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1functor__base.html">functor_base</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::functor_base Struct Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>A hint to the compiler.
+ <a href="structsigc_1_1functor__base.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/functor_trait.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::functor_base:</div>
+<div class="dyncontent">
+<div class="center"><img src="structsigc_1_1functor__base__inherit__graph.png" border="0" usemap="#asigc_1_1functor__base_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1functor__base_inherit__map" id="asigc_1_1functor__base_inherit__map">
+<area shape="rect" title="A hint to the compiler." alt="" coords="5,1877,145,1904"/>
+<area shape="rect" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="227,93,371,120"/>
+<area shape="rect" href="classsigc_1_1const__mem__functor0.html" title="const_mem_functor0 wraps const methods with 0 argument(s)." alt="" coords="202,187,395,229"/>
+<area shape="rect" href="classsigc_1_1const__mem__functor1.html" title="const_mem_functor1 wraps const methods with 1 argument(s)." alt="" coords="198,257,399,298"/>
+<area shape="rect" href="classsigc_1_1const__mem__functor2.html" title="const_mem_functor2 wraps const methods with 2 argument(s)." alt="" coords="202,323,395,379"/>
+<area shape="rect" href="classsigc_1_1const__mem__functor3.html" title="const_mem_functor3 wraps const methods with 3 argument(s)." alt="" coords="202,403,395,459"/>
+<area shape="rect" href="classsigc_1_1const__mem__functor4.html" title="const_mem_functor4 wraps const methods with 4 argument(s)." alt="" coords="202,483,395,539"/>
+<area shape="rect" href="classsigc_1_1const__mem__functor5.html" title="const_mem_functor5 wraps const methods with 5 argument(s)." alt="" coords="202,563,395,634"/>
+<area shape="rect" href="classsigc_1_1const__mem__functor6.html" title="const_mem_functor6 wraps const methods with 6 argument(s)." alt="" coords="202,658,395,729"/>
+<area shape="rect" href="classsigc_1_1const__mem__functor7.html" title="const_mem_functor7 wraps const methods with 7 argument(s)." alt="" coords="202,753,395,823"/>
+<area shape="rect" href="classsigc_1_1const__volatile__mem__functor0.html" title="const_volatile_mem_functor0 wraps const volatile methods with 0 argument(s)." alt="" coords="200,848,397,904"/>
+<area shape="rect" href="classsigc_1_1const__volatile__mem__functor1.html" title="const_volatile_mem_functor1 wraps const volatile methods with 1 argument(s)." alt="" coords="200,928,397,984"/>
+<area shape="rect" href="classsigc_1_1const__volatile__mem__functor2.html" title="const_volatile_mem_functor2 wraps const volatile methods with 2 argument(s)." alt="" coords="200,1008,397,1064"/>
+<area shape="rect" href="classsigc_1_1const__volatile__mem__functor3.html" title="const_volatile_mem_functor3 wraps const volatile methods with 3 argument(s)." alt="" coords="200,1089,397,1159"/>
+<area shape="rect" href="classsigc_1_1const__volatile__mem__functor4.html" title="const_volatile_mem_functor4 wraps const volatile methods with 4 argument(s)." alt="" coords="200,1183,397,1254"/>
+<area shape="rect" href="classsigc_1_1const__volatile__mem__functor5.html" title="const_volatile_mem_functor5 wraps const volatile methods with 5 argument(s)." alt="" coords="200,1278,397,1349"/>
+<area shape="rect" href="classsigc_1_1const__volatile__mem__functor6.html" title="const_volatile_mem_functor6 wraps const volatile methods with 6 argument(s)." alt="" coords="200,1373,397,1459"/>
+<area shape="rect" href="classsigc_1_1const__volatile__mem__functor7.html" title="const_volatile_mem_functor7 wraps const volatile methods with 7 argument(s)." alt="" coords="200,1483,397,1568"/>
+<area shape="rect" href="classsigc_1_1mem__functor0.html" title="mem_functor0 wraps methods with 0 argument(s)." alt="" coords="223,1593,374,1634"/>
+<area shape="rect" href="classsigc_1_1mem__functor1.html" title="mem_functor1 wraps methods with 1 argument(s)." alt="" coords="223,1659,374,1715"/>
+<area shape="rect" href="classsigc_1_1mem__functor2.html" title="mem_functor2 wraps methods with 2 argument(s)." alt="" coords="223,1739,374,1795"/>
+<area shape="rect" href="classsigc_1_1mem__functor3.html" title="mem_functor3 wraps methods with 3 argument(s)." alt="" coords="210,1819,387,1875"/>
+<area shape="rect" href="classsigc_1_1mem__functor4.html" title="mem_functor4 wraps methods with 4 argument(s)." alt="" coords="215,1899,382,1970"/>
+<area shape="rect" href="classsigc_1_1mem__functor5.html" title="mem_functor5 wraps methods with 5 argument(s)." alt="" coords="215,1994,382,2065"/>
+<area shape="rect" href="classsigc_1_1mem__functor6.html" title="mem_functor6 wraps methods with 6 argument(s)." alt="" coords="204,2089,393,2159"/>
+<area shape="rect" href="classsigc_1_1mem__functor7.html" title="mem_functor7 wraps methods with 7 argument(s)." alt="" coords="209,2184,388,2269"/>
+<area shape="rect" href="classsigc_1_1pointer__functor0.html" title="pointer_functor0 wraps existing non-member functions with 0 argument(s)." alt="" coords="217,2294,380,2335"/>
+<area shape="rect" href="classsigc_1_1pointer__functor1.html" title="pointer_functor1 wraps existing non-member functions with 1 argument(s)." alt="" coords="217,2359,380,2401"/>
+<area shape="rect" href="classsigc_1_1pointer__functor2.html" title="pointer_functor2 wraps existing non-member functions with 2 argument(s)." alt="" coords="193,2425,404,2466"/>
+<area shape="rect" href="classsigc_1_1pointer__functor3.html" title="pointer_functor3 wraps existing non-member functions with 3 argument(s)." alt="" coords="204,2491,393,2547"/>
+<area shape="rect" href="classsigc_1_1pointer__functor4.html" title="pointer_functor4 wraps existing non-member functions with 4 argument(s)." alt="" coords="204,2571,393,2627"/>
+<area shape="rect" href="classsigc_1_1pointer__functor5.html" title="pointer_functor5 wraps existing non-member functions with 5 argument(s)." alt="" coords="199,2651,398,2707"/>
+<area shape="rect" href="classsigc_1_1pointer__functor6.html" title="pointer_functor6 wraps existing non-member functions with 6 argument(s)." alt="" coords="204,2731,393,2802"/>
+<area shape="rect" href="classsigc_1_1pointer__functor7.html" title="pointer_functor7 wraps existing non-member functions with 7 argument(s)." alt="" coords="204,2826,393,2897"/>
+<area shape="rect" href="classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="239,2921,358,2948"/>
+<area shape="rect" href="classsigc_1_1volatile__mem__functor0.html" title="volatile_mem_functor0 wraps volatile methods with 0 argument(s)." alt="" coords="221,2972,377,3028"/>
+<area shape="rect" href="classsigc_1_1volatile__mem__functor1.html" title="volatile_mem_functor1 wraps volatile methods with 1 argument(s)." alt="" coords="221,3052,377,3108"/>
+<area shape="rect" href="classsigc_1_1volatile__mem__functor2.html" title="volatile_mem_functor2 wraps volatile methods with 2 argument(s)." alt="" coords="209,3132,389,3188"/>
+<area shape="rect" href="classsigc_1_1volatile__mem__functor3.html" title="volatile_mem_functor3 wraps volatile methods with 3 argument(s)." alt="" coords="214,3213,383,3283"/>
+<area shape="rect" href="classsigc_1_1volatile__mem__functor4.html" title="volatile_mem_functor4 wraps volatile methods with 4 argument(s)." alt="" coords="214,3307,383,3378"/>
+<area shape="rect" href="classsigc_1_1volatile__mem__functor5.html" title="volatile_mem_functor5 wraps volatile methods with 5 argument(s)." alt="" coords="204,3402,393,3473"/>
+<area shape="rect" href="classsigc_1_1volatile__mem__functor6.html" title="volatile_mem_functor6 wraps volatile methods with 6 argument(s)." alt="" coords="209,3497,388,3583"/>
+<area shape="rect" href="classsigc_1_1volatile__mem__functor7.html" title="volatile_mem_functor7 wraps volatile methods with 7 argument(s)." alt="" coords="209,3607,388,3692"/>
+<area shape="rect" href="structsigc_1_1adapts.html" title=" " alt="" coords="456,5,639,32"/>
+<area shape="rect" href="structsigc_1_1adaptor__functor.html" title="Converts an arbitrary functor into an adaptor type." alt="" coords="468,57,627,98"/>
+<area shape="rect" href="structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="452,123,643,149"/>
+<area shape="rect" href="classsigc_1_1bound__const__mem__functor0.html" title="bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance." alt="" coords="458,173,637,229"/>
+<area shape="rect" href="classsigc_1_1bound__const__mem__functor1.html" title="bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance." alt="" coords="458,253,637,309"/>
+<area shape="rect" href="classsigc_1_1bound__const__mem__functor2.html" title="bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance." alt="" coords="457,333,637,389"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><p>A hint to the compiler. </p>
+<p>All functors which define <code>result_type</code> should publically inherit from this hint. </p>
+</div></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::functor_base" name="sigc::functor_base">
+<area shape="rect" id="node1" title="A hint to the compiler." alt="" coords="5,1877,145,1904"/>
+<area shape="rect" id="node2" href="$structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="227,93,371,120"/>
+<area shape="rect" id="node6" href="$classsigc_1_1const__mem__functor0.html" title="const_mem_functor0 wraps const methods with 0 argument(s)." alt="" coords="202,187,395,229"/>
+<area shape="rect" id="node8" href="$classsigc_1_1const__mem__functor1.html" title="const_mem_functor1 wraps const methods with 1 argument(s)." alt="" coords="198,257,399,298"/>
+<area shape="rect" id="node10" href="$classsigc_1_1const__mem__functor2.html" title="const_mem_functor2 wraps const methods with 2 argument(s)." alt="" coords="202,323,395,379"/>
+<area shape="rect" id="node12" href="$classsigc_1_1const__mem__functor3.html" title="const_mem_functor3 wraps const methods with 3 argument(s)." alt="" coords="202,403,395,459"/>
+<area shape="rect" id="node13" href="$classsigc_1_1const__mem__functor4.html" title="const_mem_functor4 wraps const methods with 4 argument(s)." alt="" coords="202,483,395,539"/>
+<area shape="rect" id="node14" href="$classsigc_1_1const__mem__functor5.html" title="const_mem_functor5 wraps const methods with 5 argument(s)." alt="" coords="202,563,395,634"/>
+<area shape="rect" id="node15" href="$classsigc_1_1const__mem__functor6.html" title="const_mem_functor6 wraps const methods with 6 argument(s)." alt="" coords="202,658,395,729"/>
+<area shape="rect" id="node16" href="$classsigc_1_1const__mem__functor7.html" title="const_mem_functor7 wraps const methods with 7 argument(s)." alt="" coords="202,753,395,823"/>
+<area shape="rect" id="node17" href="$classsigc_1_1const__volatile__mem__functor0.html" title="const_volatile_mem_functor0 wraps const volatile methods with 0 argument(s)." alt="" coords="200,848,397,904"/>
+<area shape="rect" id="node18" href="$classsigc_1_1const__volatile__mem__functor1.html" title="const_volatile_mem_functor1 wraps const volatile methods with 1 argument(s)." alt="" coords="200,928,397,984"/>
+<area shape="rect" id="node19" href="$classsigc_1_1const__volatile__mem__functor2.html" title="const_volatile_mem_functor2 wraps const volatile methods with 2 argument(s)." alt="" coords="200,1008,397,1064"/>
+<area shape="rect" id="node20" href="$classsigc_1_1const__volatile__mem__functor3.html" title="const_volatile_mem_functor3 wraps const volatile methods with 3 argument(s)." alt="" coords="200,1089,397,1159"/>
+<area shape="rect" id="node21" href="$classsigc_1_1const__volatile__mem__functor4.html" title="const_volatile_mem_functor4 wraps const volatile methods with 4 argument(s)." alt="" coords="200,1183,397,1254"/>
+<area shape="rect" id="node22" href="$classsigc_1_1const__volatile__mem__functor5.html" title="const_volatile_mem_functor5 wraps const volatile methods with 5 argument(s)." alt="" coords="200,1278,397,1349"/>
+<area shape="rect" id="node23" href="$classsigc_1_1const__volatile__mem__functor6.html" title="const_volatile_mem_functor6 wraps const volatile methods with 6 argument(s)." alt="" coords="200,1373,397,1459"/>
+<area shape="rect" id="node24" href="$classsigc_1_1const__volatile__mem__functor7.html" title="const_volatile_mem_functor7 wraps const volatile methods with 7 argument(s)." alt="" coords="200,1483,397,1568"/>
+<area shape="rect" id="node25" href="$classsigc_1_1mem__functor0.html" title="mem_functor0 wraps methods with 0 argument(s)." alt="" coords="223,1593,374,1634"/>
+<area shape="rect" id="node26" href="$classsigc_1_1mem__functor1.html" title="mem_functor1 wraps methods with 1 argument(s)." alt="" coords="223,1659,374,1715"/>
+<area shape="rect" id="node27" href="$classsigc_1_1mem__functor2.html" title="mem_functor2 wraps methods with 2 argument(s)." alt="" coords="223,1739,374,1795"/>
+<area shape="rect" id="node28" href="$classsigc_1_1mem__functor3.html" title="mem_functor3 wraps methods with 3 argument(s)." alt="" coords="210,1819,387,1875"/>
+<area shape="rect" id="node29" href="$classsigc_1_1mem__functor4.html" title="mem_functor4 wraps methods with 4 argument(s)." alt="" coords="215,1899,382,1970"/>
+<area shape="rect" id="node30" href="$classsigc_1_1mem__functor5.html" title="mem_functor5 wraps methods with 5 argument(s)." alt="" coords="215,1994,382,2065"/>
+<area shape="rect" id="node31" href="$classsigc_1_1mem__functor6.html" title="mem_functor6 wraps methods with 6 argument(s)." alt="" coords="204,2089,393,2159"/>
+<area shape="rect" id="node32" href="$classsigc_1_1mem__functor7.html" title="mem_functor7 wraps methods with 7 argument(s)." alt="" coords="209,2184,388,2269"/>
+<area shape="rect" id="node33" href="$classsigc_1_1pointer__functor0.html" title="pointer_functor0 wraps existing non-member functions with 0 argument(s)." alt="" coords="217,2294,380,2335"/>
+<area shape="rect" id="node34" href="$classsigc_1_1pointer__functor1.html" title="pointer_functor1 wraps existing non-member functions with 1 argument(s)." alt="" coords="217,2359,380,2401"/>
+<area shape="rect" id="node35" href="$classsigc_1_1pointer__functor2.html" title="pointer_functor2 wraps existing non-member functions with 2 argument(s)." alt="" coords="193,2425,404,2466"/>
+<area shape="rect" id="node36" href="$classsigc_1_1pointer__functor3.html" title="pointer_functor3 wraps existing non-member functions with 3 argument(s)." alt="" coords="204,2491,393,2547"/>
+<area shape="rect" id="node37" href="$classsigc_1_1pointer__functor4.html" title="pointer_functor4 wraps existing non-member functions with 4 argument(s)." alt="" coords="204,2571,393,2627"/>
+<area shape="rect" id="node38" href="$classsigc_1_1pointer__functor5.html" title="pointer_functor5 wraps existing non-member functions with 5 argument(s)." alt="" coords="199,2651,398,2707"/>
+<area shape="rect" id="node39" href="$classsigc_1_1pointer__functor6.html" title="pointer_functor6 wraps existing non-member functions with 6 argument(s)." alt="" coords="204,2731,393,2802"/>
+<area shape="rect" id="node40" href="$classsigc_1_1pointer__functor7.html" title="pointer_functor7 wraps existing non-member functions with 7 argument(s)." alt="" coords="204,2826,393,2897"/>
+<area shape="rect" id="node41" href="$classsigc_1_1slot__base.html" title="Base type for slots." alt="" coords="239,2921,358,2948"/>
+<area shape="rect" id="node42" href="$classsigc_1_1volatile__mem__functor0.html" title="volatile_mem_functor0 wraps volatile methods with 0 argument(s)." alt="" coords="221,2972,377,3028"/>
+<area shape="rect" id="node43" href="$classsigc_1_1volatile__mem__functor1.html" title="volatile_mem_functor1 wraps volatile methods with 1 argument(s)." alt="" coords="221,3052,377,3108"/>
+<area shape="rect" id="node44" href="$classsigc_1_1volatile__mem__functor2.html" title="volatile_mem_functor2 wraps volatile methods with 2 argument(s)." alt="" coords="209,3132,389,3188"/>
+<area shape="rect" id="node45" href="$classsigc_1_1volatile__mem__functor3.html" title="volatile_mem_functor3 wraps volatile methods with 3 argument(s)." alt="" coords="214,3213,383,3283"/>
+<area shape="rect" id="node46" href="$classsigc_1_1volatile__mem__functor4.html" title="volatile_mem_functor4 wraps volatile methods with 4 argument(s)." alt="" coords="214,3307,383,3378"/>
+<area shape="rect" id="node47" href="$classsigc_1_1volatile__mem__functor5.html" title="volatile_mem_functor5 wraps volatile methods with 5 argument(s)." alt="" coords="204,3402,393,3473"/>
+<area shape="rect" id="node48" href="$classsigc_1_1volatile__mem__functor6.html" title="volatile_mem_functor6 wraps volatile methods with 6 argument(s)." alt="" coords="209,3497,388,3583"/>
+<area shape="rect" id="node49" href="$classsigc_1_1volatile__mem__functor7.html" title="volatile_mem_functor7 wraps volatile methods with 7 argument(s)." alt="" coords="209,3607,388,3692"/>
+<area shape="rect" id="node3" href="$structsigc_1_1adapts.html" title=" " alt="" coords="456,5,639,32"/>
+<area shape="rect" id="node4" href="$structsigc_1_1adaptor__functor.html" title="Converts an arbitrary functor into an adaptor type." alt="" coords="468,57,627,98"/>
+<area shape="rect" id="node5" href="$structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="452,123,643,149"/>
+<area shape="rect" id="node7" href="$classsigc_1_1bound__const__mem__functor0.html" title="bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance." alt="" coords="458,173,637,229"/>
+<area shape="rect" id="node9" href="$classsigc_1_1bound__const__mem__functor1.html" title="bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance." alt="" coords="458,253,637,309"/>
+<area shape="rect" id="node11" href="$classsigc_1_1bound__const__mem__functor2.html" title="bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance." alt="" coords="457,333,637,389"/>
+</map>
--- /dev/null
+0d2671fee565ac6f187163aa523ab3f9
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1functor__trait.html">functor_trait</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::functor_trait< T_functor, I_derives_functor_base, I_can_use_decltype > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1functor__trait.html">sigc::functor_trait< T_functor, I_derives_functor_base, I_can_use_decltype ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1functor__trait.html#ac779b3d3d04e78d57b6b2ae4545b1667">functor_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1functor__trait.html">sigc::functor_trait< T_functor, I_derives_functor_base, I_can_use_decltype ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1functor__trait.html#af1324bf0d3cec3d1f2e39e932b228d6d">result_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1functor__trait.html">sigc::functor_trait< T_functor, I_derives_functor_base, I_can_use_decltype ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::functor_trait< T_functor, I_derives_functor_base, I_can_use_decltype > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1functor__trait.html">functor_trait</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="structsigc_1_1functor__trait-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::functor_trait< T_functor, I_derives_functor_base, I_can_use_decltype > Struct Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Trait that specifies the return type of any type.
+ <a href="structsigc_1_1functor__trait.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/functor_trait.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:ac779b3d3d04e78d57b6b2ae4545b1667"><td class="memItemLeft" align="right" valign="top">typedef T_functor </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1functor__trait.html#ac779b3d3d04e78d57b6b2ae4545b1667">functor_type</a></td></tr>
+<tr class="separator:ac779b3d3d04e78d57b6b2ae4545b1667"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af1324bf0d3cec3d1f2e39e932b228d6d"><td class="memItemLeft" align="right" valign="top">typedef void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1functor__trait.html#af1324bf0d3cec3d1f2e39e932b228d6d">result_type</a></td></tr>
+<tr class="separator:af1324bf0d3cec3d1f2e39e932b228d6d"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_functor, bool I_derives_functor_base = std::is_base_of<functor_base,T_functor>::value, bool I_can_use_decltype = can_deduce_result_type_with_decltype<T_functor>::value><br />
+struct sigc::functor_trait< T_functor, I_derives_functor_base, I_can_use_decltype ></h3>
+
+<p>Trait that specifies the return type of any type. </p>
+<p>Template specializations for functors derived from <a class="el" href="structsigc_1_1functor__base.html" title="A hint to the compiler.">sigc::functor_base</a>, for other functors whose result type can be deduced with decltype(), for function pointers and for class methods are provided.</p>
+<dl class="tparams"><dt>Template Parameters</dt><dd>
+ <table class="tparams">
+ <tr><td class="paramname">T_functor</td><td>Functor type. </td></tr>
+ <tr><td class="paramname">I_derives_functor_base</td><td>Whether <code>T_functor</code> inherits from <a class="el" href="structsigc_1_1functor__base.html" title="A hint to the compiler.">sigc::functor_base</a>. </td></tr>
+ <tr><td class="paramname">I_can_use_decltype</td><td>Whether the result type of <code>T_functor</code> can be deduced with decltype(). </td></tr>
+ </table>
+ </dd>
+</dl>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="ac779b3d3d04e78d57b6b2ae4545b1667"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac779b3d3d04e78d57b6b2ae4545b1667">◆ </a></span>functor_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , bool I_derives_functor_base = std::is_base_of<functor_base,T_functor>::value, bool I_can_use_decltype = can_deduce_result_type_with_decltype<T_functor>::value> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_functor <a class="el" href="structsigc_1_1functor__trait.html">sigc::functor_trait</a>< T_functor, I_derives_functor_base, I_can_use_decltype >::<a class="el" href="structsigc_1_1functor__trait.html#ac779b3d3d04e78d57b6b2ae4545b1667">functor_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="af1324bf0d3cec3d1f2e39e932b228d6d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af1324bf0d3cec3d1f2e39e932b228d6d">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , bool I_derives_functor_base = std::is_base_of<functor_base,T_functor>::value, bool I_can_use_decltype = can_deduce_result_type_with_decltype<T_functor>::value> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef void <a class="el" href="structsigc_1_1functor__trait.html">sigc::functor_trait</a>< T_functor, I_derives_functor_base, I_can_use_decltype >::<a class="el" href="structsigc_1_1functor__trait.html#af1324bf0d3cec3d1f2e39e932b228d6d">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::hide_functor< I_location, T_functor > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1hide__functor.html">hide_functor</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::hide_functor< I_location, T_functor > Struct Template Reference<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a> » <a class="el" href="group__hide.html">hide(), hide_return()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Adaptor that adds a dummy parameter to the wrapped functor.
+ <a href="structsigc_1_1hide__functor.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/hide.h></code></p>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<int I_location, class T_functor><br />
+struct sigc::hide_functor< I_location, T_functor ></h3>
+
+<p>Adaptor that adds a dummy parameter to the wrapped functor. </p>
+<p>Use the convenience function <a class="el" href="group__hide.html#gaf2cefea3a99acd44f68121424103172d" title="Creates an adaptor of type sigc::hide_functor which adds a dummy parameter to the passed functor.">sigc::hide()</a> to create an instance of <a class="el" href="structsigc_1_1hide__functor.html" title="Adaptor that adds a dummy parameter to the wrapped functor.">sigc::hide_functor</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>I_location</em> Zero-based position of the dummy parameter (<code>-1</code> for the last parameter).</li>
+<li><em>T_type</em> Type of the dummy parameter.</li>
+<li><em>T_functor</em> Type of the functor to wrap. </li>
+</ul>
+</div></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html">hide_functor<-1, T_functor ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::hide_functor<-1, T_functor > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html">sigc::hide_functor<-1, T_functor ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a1f2c49ddcd02a3b7f240f0d0e6f0eec5">adaptor_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html">sigc::hide_functor<-1, T_functor ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a>(const T_functor & _A_functor)</td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a4c8d774e447991a6a920b9f3fca63205">hide_functor</a>(const T_functor & _A_func)</td><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html">sigc::hide_functor<-1, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a0b2aed34c7b1c58fc9735ec4578bd6c2">operator()</a>(T_arg1)</td><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html">sigc::hide_functor<-1, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#af4b6fe456f259ae4a9973c2feaebb9f5">operator()</a>(T_arg1 _A_a1, T_arg2)</td><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html">sigc::hide_functor<-1, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a8a00e3b27c18520ff693b379aa3db3da">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3)</td><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html">sigc::hide_functor<-1, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a576f3873a5e2444cec82b04f82b1e01e">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4)</td><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html">sigc::hide_functor<-1, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a1b14612df4daabfa76ddb5aa9d48c023">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5)</td><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html">sigc::hide_functor<-1, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a4c9d0e81c0dacb65443b810ba90f81b7">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6)</td><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html">sigc::hide_functor<-1, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a3ab506b688835f9545dc018142cc728e">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7)</td><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html">sigc::hide_functor<-1, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a72ea0ce5ad7cf4f9e0e7b160d830c5a4">result_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html">sigc::hide_functor<-1, T_functor ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::hide_functor<-1, T_functor > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html">hide_functor<-1, T_functor ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::hide_functor<-1, T_functor > Struct Template Reference<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a> » <a class="el" href="group__hide.html">hide(), hide_return()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Adaptor that adds a dummy parameter to the wrapped functor.
+ <a href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/hide.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::hide_functor<-1, T_functor >:</div>
+<div class="dyncontent">
+<div class="center"><img src="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4__inherit__graph.png" border="0" usemap="#asigc_1_1hide__functor_3-1_00_01T__functor_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1hide__functor_3-1_00_01T__functor_01_4_inherit__map" id="asigc_1_1hide__functor_3-1_00_01T__functor_01_4_inherit__map">
+<area shape="rect" title="Adaptor that adds a dummy parameter to the wrapped functor." alt="" coords="32,229,169,271"/>
+<area shape="rect" href="structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="5,155,196,181"/>
+<area shape="rect" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="29,80,173,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="31,5,171,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a1f2c49ddcd02a3b7f240f0d0e6f0eec5"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adapts.html">adapts</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a1f2c49ddcd02a3b7f240f0d0e6f0eec5">adaptor_type</a></td></tr>
+<tr class="separator:a1f2c49ddcd02a3b7f240f0d0e6f0eec5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a72ea0ce5ad7cf4f9e0e7b160d830c5a4"><td class="memItemLeft" align="right" valign="top">typedef adaptor_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a72ea0ce5ad7cf4f9e0e7b160d830c5a4">result_type</a></td></tr>
+<tr class="separator:a72ea0ce5ad7cf4f9e0e7b160d830c5a4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td></tr>
+<tr class="separator:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td></tr>
+<tr class="separator:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a4c8d774e447991a6a920b9f3fca63205"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a4c8d774e447991a6a920b9f3fca63205">hide_functor</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:a4c8d774e447991a6a920b9f3fca63205"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="structsigc_1_1hide__functor.html" title="Adaptor that adds a dummy parameter to the wrapped functor.">hide_functor</a> object that adds a dummy parameter to the passed functor. <a href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a4c8d774e447991a6a920b9f3fca63205">More...</a><br /></td></tr>
+<tr class="separator:a4c8d774e447991a6a920b9f3fca63205"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3ab506b688835f9545dc018142cc728e"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:a3ab506b688835f9545dc018142cc728e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a3ab506b688835f9545dc018142cc728e">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7)</td></tr>
+<tr class="memdesc:a3ab506b688835f9545dc018142cc728e"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor, ignoring the last argument. <a href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a3ab506b688835f9545dc018142cc728e">More...</a><br /></td></tr>
+<tr class="separator:a3ab506b688835f9545dc018142cc728e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4c9d0e81c0dacb65443b810ba90f81b7"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:a4c9d0e81c0dacb65443b810ba90f81b7"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a4c9d0e81c0dacb65443b810ba90f81b7">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6)</td></tr>
+<tr class="memdesc:a4c9d0e81c0dacb65443b810ba90f81b7"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor, ignoring the last argument. <a href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a4c9d0e81c0dacb65443b810ba90f81b7">More...</a><br /></td></tr>
+<tr class="separator:a4c9d0e81c0dacb65443b810ba90f81b7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1b14612df4daabfa76ddb5aa9d48c023"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:a1b14612df4daabfa76ddb5aa9d48c023"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a1b14612df4daabfa76ddb5aa9d48c023">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5)</td></tr>
+<tr class="memdesc:a1b14612df4daabfa76ddb5aa9d48c023"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor, ignoring the last argument. <a href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a1b14612df4daabfa76ddb5aa9d48c023">More...</a><br /></td></tr>
+<tr class="separator:a1b14612df4daabfa76ddb5aa9d48c023"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a576f3873a5e2444cec82b04f82b1e01e"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:a576f3873a5e2444cec82b04f82b1e01e"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a576f3873a5e2444cec82b04f82b1e01e">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4)</td></tr>
+<tr class="memdesc:a576f3873a5e2444cec82b04f82b1e01e"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor, ignoring the last argument. <a href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a576f3873a5e2444cec82b04f82b1e01e">More...</a><br /></td></tr>
+<tr class="separator:a576f3873a5e2444cec82b04f82b1e01e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8a00e3b27c18520ff693b379aa3db3da"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:a8a00e3b27c18520ff693b379aa3db3da"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a8a00e3b27c18520ff693b379aa3db3da">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3)</td></tr>
+<tr class="memdesc:a8a00e3b27c18520ff693b379aa3db3da"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor, ignoring the last argument. <a href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a8a00e3b27c18520ff693b379aa3db3da">More...</a><br /></td></tr>
+<tr class="separator:a8a00e3b27c18520ff693b379aa3db3da"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af4b6fe456f259ae4a9973c2feaebb9f5"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:af4b6fe456f259ae4a9973c2feaebb9f5"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#af4b6fe456f259ae4a9973c2feaebb9f5">operator()</a> (T_arg1 _A_a1, T_arg2)</td></tr>
+<tr class="memdesc:af4b6fe456f259ae4a9973c2feaebb9f5"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor, ignoring the last argument. <a href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#af4b6fe456f259ae4a9973c2feaebb9f5">More...</a><br /></td></tr>
+<tr class="separator:af4b6fe456f259ae4a9973c2feaebb9f5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0b2aed34c7b1c58fc9735ec4578bd6c2"><td class="memTemplParams" colspan="2">template<class T_arg1 > </td></tr>
+<tr class="memitem:a0b2aed34c7b1c58fc9735ec4578bd6c2"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a0b2aed34c7b1c58fc9735ec4578bd6c2">operator()</a> (T_arg1)</td></tr>
+<tr class="memdesc:a0b2aed34c7b1c58fc9735ec4578bd6c2"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor ignoring the only argument. <a href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a0b2aed34c7b1c58fc9735ec4578bd6c2">More...</a><br /></td></tr>
+<tr class="separator:a0b2aed34c7b1c58fc9735ec4578bd6c2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a> (const T_functor & _A_functor)</td></tr>
+<tr class="memdesc:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an adaptor that wraps the passed functor. <a href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">More...</a><br /></td></tr>
+<tr class="separator:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_attribs_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td></tr>
+<tr class="memdesc:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that is invoked from operator()(). <a href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">More...</a><br /></td></tr>
+<tr class="separator:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_functor><br />
+struct sigc::hide_functor<-1, T_functor ></h3>
+
+<p>Adaptor that adds a dummy parameter to the wrapped functor. </p>
+<p>This template specialization ignores the value of the last parameter in <a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a0b2aed34c7b1c58fc9735ec4578bd6c2" title="Invokes the wrapped functor ignoring the only argument.">operator()()</a>. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a1f2c49ddcd02a3b7f240f0d0e6f0eec5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1f2c49ddcd02a3b7f240f0d0e6f0eec5">◆ </a></span>adaptor_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1adapts.html">adapts</a><T_functor>::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> <a class="el" href="structsigc_1_1hide__functor.html">sigc::hide_functor</a><-1, T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a72ea0ce5ad7cf4f9e0e7b160d830c5a4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a72ea0ce5ad7cf4f9e0e7b160d830c5a4">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef adaptor_type::result_type <a class="el" href="structsigc_1_1hide__functor.html">sigc::hide_functor</a><-1, T_functor >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a4c8d774e447991a6a920b9f3fca63205"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4c8d774e447991a6a920b9f3fca63205">◆ </a></span>hide_functor()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1hide__functor.html">sigc::hide_functor</a><-1, T_functor >::<a class="el" href="structsigc_1_1hide__functor.html">hide_functor</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="structsigc_1_1hide__functor.html" title="Adaptor that adds a dummy parameter to the wrapped functor.">hide_functor</a> object that adds a dummy parameter to the passed functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Functor to invoke from <a class="el" href="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a0b2aed34c7b1c58fc9735ec4578bd6c2" title="Invokes the wrapped functor ignoring the only argument.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a3ab506b688835f9545dc018142cc728e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3ab506b688835f9545dc018142cc728e">◆ </a></span>operator()() <span class="overload">[1/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type <a class="el" href="structsigc_1_1hide__functor.html">sigc::hide_functor</a><-1, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg6 </td>
+ <td class="paramname"><em>_A_a6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg7 </td>
+ <td class="paramname"> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor, ignoring the last argument. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a7</td><td>Argument to be ignored. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a4c9d0e81c0dacb65443b810ba90f81b7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4c9d0e81c0dacb65443b810ba90f81b7">◆ </a></span>operator()() <span class="overload">[2/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type <a class="el" href="structsigc_1_1hide__functor.html">sigc::hide_functor</a><-1, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg6 </td>
+ <td class="paramname"> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor, ignoring the last argument. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be ignored. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a1b14612df4daabfa76ddb5aa9d48c023"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1b14612df4daabfa76ddb5aa9d48c023">◆ </a></span>operator()() <span class="overload">[3/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type <a class="el" href="structsigc_1_1hide__functor.html">sigc::hide_functor</a><-1, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor, ignoring the last argument. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be ignored. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a576f3873a5e2444cec82b04f82b1e01e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a576f3873a5e2444cec82b04f82b1e01e">◆ </a></span>operator()() <span class="overload">[4/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4>::type <a class="el" href="structsigc_1_1hide__functor.html">sigc::hide_functor</a><-1, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor, ignoring the last argument. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be ignored. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a8a00e3b27c18520ff693b379aa3db3da"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8a00e3b27c18520ff693b379aa3db3da">◆ </a></span>operator()() <span class="overload">[5/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3>::type <a class="el" href="structsigc_1_1hide__functor.html">sigc::hide_functor</a><-1, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor, ignoring the last argument. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be ignored. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="af4b6fe456f259ae4a9973c2feaebb9f5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af4b6fe456f259ae4a9973c2feaebb9f5">◆ </a></span>operator()() <span class="overload">[6/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2>::type <a class="el" href="structsigc_1_1hide__functor.html">sigc::hide_functor</a><-1, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor, ignoring the last argument. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be ignored. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a0b2aed34c7b1c58fc9735ec4578bd6c2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0b2aed34c7b1c58fc9735ec4578bd6c2">◆ </a></span>operator()() <span class="overload">[7/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1>::type <a class="el" href="structsigc_1_1hide__functor.html">sigc::hide_functor</a><-1, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor ignoring the only argument. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be ignored. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::hide_functor<-1, T_functor >" name="sigc::hide_functor<-1, T_functor >">
+<area shape="rect" id="node1" title="Adaptor that adds a dummy parameter to the wrapped functor." alt="" coords="32,229,169,271"/>
+<area shape="rect" id="node2" href="$structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="5,155,196,181"/>
+<area shape="rect" id="node3" href="$structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="29,80,173,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="31,5,171,32"/>
+</map>
--- /dev/null
+effaced3bab439e869ff9aed04958f88
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html">hide_functor< 0, T_functor ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::hide_functor< 0, T_functor > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html">sigc::hide_functor< 0, T_functor ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a33b1c4635aad21aac771627a9a9fe60f">adaptor_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html">sigc::hide_functor< 0, T_functor ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a>(const T_functor & _A_functor)</td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a7d5504f337ab7a4b6f709219c9e98222">hide_functor</a>(const T_functor & _A_func)</td><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html">sigc::hide_functor< 0, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a556774f196a4ec5569e8404ba8ae1539">operator()</a>(T_arg1)</td><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html">sigc::hide_functor< 0, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#ad6b459b35d0bf0e337fdef4780e68840">operator()</a>(T_arg1, T_arg2 _A_a2)</td><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html">sigc::hide_functor< 0, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a5390f82ac4049f2a22ef1f4896a508dd">operator()</a>(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3)</td><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html">sigc::hide_functor< 0, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a587bc5d423b0b38722764c9f0792e73c">operator()</a>(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)</td><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html">sigc::hide_functor< 0, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a9c8415cad0f615bb1a24cf8e8a985cf7">operator()</a>(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)</td><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html">sigc::hide_functor< 0, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a62027eafacff15f5f7efaefd204f1908">operator()</a>(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)</td><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html">sigc::hide_functor< 0, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a599128c72562bd8de98c37f046471080">operator()</a>(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)</td><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html">sigc::hide_functor< 0, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#af5b5ee49bb277471b5bc8e3769d0dcb7">result_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html">sigc::hide_functor< 0, T_functor ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::hide_functor< 0, T_functor > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html">hide_functor< 0, T_functor ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::hide_functor< 0, T_functor > Struct Template Reference<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a> » <a class="el" href="group__hide.html">hide(), hide_return()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Adaptor that adds a dummy parameter to the wrapped functor.
+ <a href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/hide.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::hide_functor< 0, T_functor >:</div>
+<div class="dyncontent">
+<div class="center"><img src="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4__inherit__graph.png" border="0" usemap="#asigc_1_1hide__functor_3_010_00_01T__functor_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1hide__functor_3_010_00_01T__functor_01_4_inherit__map" id="asigc_1_1hide__functor_3_010_00_01T__functor_01_4_inherit__map">
+<area shape="rect" title="Adaptor that adds a dummy parameter to the wrapped functor." alt="" coords="32,229,169,271"/>
+<area shape="rect" href="structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="5,155,196,181"/>
+<area shape="rect" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="29,80,173,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="31,5,171,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a33b1c4635aad21aac771627a9a9fe60f"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adapts.html">adapts</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a33b1c4635aad21aac771627a9a9fe60f">adaptor_type</a></td></tr>
+<tr class="separator:a33b1c4635aad21aac771627a9a9fe60f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af5b5ee49bb277471b5bc8e3769d0dcb7"><td class="memItemLeft" align="right" valign="top">typedef adaptor_type::result_type </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#af5b5ee49bb277471b5bc8e3769d0dcb7">result_type</a></td></tr>
+<tr class="separator:af5b5ee49bb277471b5bc8e3769d0dcb7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td></tr>
+<tr class="separator:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td></tr>
+<tr class="separator:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a7d5504f337ab7a4b6f709219c9e98222"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a7d5504f337ab7a4b6f709219c9e98222">hide_functor</a> (const T_functor & _A_func)</td></tr>
+<tr class="memdesc:a7d5504f337ab7a4b6f709219c9e98222"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="structsigc_1_1hide__functor.html" title="Adaptor that adds a dummy parameter to the wrapped functor.">hide_functor</a> object that adds a dummy parameter to the passed functor. <a href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a7d5504f337ab7a4b6f709219c9e98222">More...</a><br /></td></tr>
+<tr class="separator:a7d5504f337ab7a4b6f709219c9e98222"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a556774f196a4ec5569e8404ba8ae1539"><td class="memTemplParams" colspan="2">template<class T_arg1 > </td></tr>
+<tr class="memitem:a556774f196a4ec5569e8404ba8ae1539"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a556774f196a4ec5569e8404ba8ae1539">operator()</a> (T_arg1)</td></tr>
+<tr class="memdesc:a556774f196a4ec5569e8404ba8ae1539"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor ignoring the only argument. <a href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a556774f196a4ec5569e8404ba8ae1539">More...</a><br /></td></tr>
+<tr class="separator:a556774f196a4ec5569e8404ba8ae1539"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad6b459b35d0bf0e337fdef4780e68840"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:ad6b459b35d0bf0e337fdef4780e68840"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#ad6b459b35d0bf0e337fdef4780e68840">operator()</a> (T_arg1, T_arg2 _A_a2)</td></tr>
+<tr class="memdesc:ad6b459b35d0bf0e337fdef4780e68840"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor, ignoring the 1st argument. <a href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#ad6b459b35d0bf0e337fdef4780e68840">More...</a><br /></td></tr>
+<tr class="separator:ad6b459b35d0bf0e337fdef4780e68840"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5390f82ac4049f2a22ef1f4896a508dd"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:a5390f82ac4049f2a22ef1f4896a508dd"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a5390f82ac4049f2a22ef1f4896a508dd">operator()</a> (T_arg1, T_arg2 _A_a2, T_arg3 _A_a3)</td></tr>
+<tr class="memdesc:a5390f82ac4049f2a22ef1f4896a508dd"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor, ignoring the 1st argument. <a href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a5390f82ac4049f2a22ef1f4896a508dd">More...</a><br /></td></tr>
+<tr class="separator:a5390f82ac4049f2a22ef1f4896a508dd"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a587bc5d423b0b38722764c9f0792e73c"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:a587bc5d423b0b38722764c9f0792e73c"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a587bc5d423b0b38722764c9f0792e73c">operator()</a> (T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)</td></tr>
+<tr class="memdesc:a587bc5d423b0b38722764c9f0792e73c"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor, ignoring the 1st argument. <a href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a587bc5d423b0b38722764c9f0792e73c">More...</a><br /></td></tr>
+<tr class="separator:a587bc5d423b0b38722764c9f0792e73c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9c8415cad0f615bb1a24cf8e8a985cf7"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:a9c8415cad0f615bb1a24cf8e8a985cf7"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a9c8415cad0f615bb1a24cf8e8a985cf7">operator()</a> (T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)</td></tr>
+<tr class="memdesc:a9c8415cad0f615bb1a24cf8e8a985cf7"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor, ignoring the 1st argument. <a href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a9c8415cad0f615bb1a24cf8e8a985cf7">More...</a><br /></td></tr>
+<tr class="separator:a9c8415cad0f615bb1a24cf8e8a985cf7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a62027eafacff15f5f7efaefd204f1908"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:a62027eafacff15f5f7efaefd204f1908"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a62027eafacff15f5f7efaefd204f1908">operator()</a> (T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)</td></tr>
+<tr class="memdesc:a62027eafacff15f5f7efaefd204f1908"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor, ignoring the 1st argument. <a href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a62027eafacff15f5f7efaefd204f1908">More...</a><br /></td></tr>
+<tr class="separator:a62027eafacff15f5f7efaefd204f1908"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a599128c72562bd8de98c37f046471080"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:a599128c72562bd8de98c37f046471080"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a599128c72562bd8de98c37f046471080">operator()</a> (T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)</td></tr>
+<tr class="memdesc:a599128c72562bd8de98c37f046471080"><td class="mdescLeft"> </td><td class="mdescRight">Invokes the wrapped functor, ignoring the 1st argument. <a href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a599128c72562bd8de98c37f046471080">More...</a><br /></td></tr>
+<tr class="separator:a599128c72562bd8de98c37f046471080"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a> (const T_functor & _A_functor)</td></tr>
+<tr class="memdesc:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an adaptor that wraps the passed functor. <a href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">More...</a><br /></td></tr>
+<tr class="separator:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_attribs_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td></tr>
+<tr class="memdesc:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that is invoked from operator()(). <a href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">More...</a><br /></td></tr>
+<tr class="separator:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_functor><br />
+struct sigc::hide_functor< 0, T_functor ></h3>
+
+<p>Adaptor that adds a dummy parameter to the wrapped functor. </p>
+<p>This template specialization ignores the value of the 1st parameter in <a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a556774f196a4ec5569e8404ba8ae1539" title="Invokes the wrapped functor ignoring the only argument.">operator()()</a>. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a33b1c4635aad21aac771627a9a9fe60f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a33b1c4635aad21aac771627a9a9fe60f">◆ </a></span>adaptor_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1adapts.html">adapts</a><T_functor>::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> <a class="el" href="structsigc_1_1hide__functor.html">sigc::hide_functor</a>< 0, T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="af5b5ee49bb277471b5bc8e3769d0dcb7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af5b5ee49bb277471b5bc8e3769d0dcb7">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef adaptor_type::result_type <a class="el" href="structsigc_1_1hide__functor.html">sigc::hide_functor</a>< 0, T_functor >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a7d5504f337ab7a4b6f709219c9e98222"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7d5504f337ab7a4b6f709219c9e98222">◆ </a></span>hide_functor()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1hide__functor.html">sigc::hide_functor</a>< 0, T_functor >::<a class="el" href="structsigc_1_1hide__functor.html">hide_functor</a> </td>
+ <td>(</td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_func</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="structsigc_1_1hide__functor.html" title="Adaptor that adds a dummy parameter to the wrapped functor.">hide_functor</a> object that adds a dummy parameter to the passed functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_func</td><td>Functor to invoke from <a class="el" href="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a556774f196a4ec5569e8404ba8ae1539" title="Invokes the wrapped functor ignoring the only argument.">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a556774f196a4ec5569e8404ba8ae1539"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a556774f196a4ec5569e8404ba8ae1539">◆ </a></span>operator()() <span class="overload">[1/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1>::type <a class="el" href="structsigc_1_1hide__functor.html">sigc::hide_functor</a>< 0, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor ignoring the only argument. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be ignored. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="ad6b459b35d0bf0e337fdef4780e68840"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad6b459b35d0bf0e337fdef4780e68840">◆ </a></span>operator()() <span class="overload">[2/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2>::type <a class="el" href="structsigc_1_1hide__functor.html">sigc::hide_functor</a>< 0, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname">, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor, ignoring the 1st argument. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be ignored. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a5390f82ac4049f2a22ef1f4896a508dd"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5390f82ac4049f2a22ef1f4896a508dd">◆ </a></span>operator()() <span class="overload">[3/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3>::type <a class="el" href="structsigc_1_1hide__functor.html">sigc::hide_functor</a>< 0, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname">, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor, ignoring the 1st argument. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be ignored. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a587bc5d423b0b38722764c9f0792e73c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a587bc5d423b0b38722764c9f0792e73c">◆ </a></span>operator()() <span class="overload">[4/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4>::type <a class="el" href="structsigc_1_1hide__functor.html">sigc::hide_functor</a>< 0, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname">, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor, ignoring the 1st argument. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be ignored. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a9c8415cad0f615bb1a24cf8e8a985cf7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9c8415cad0f615bb1a24cf8e8a985cf7">◆ </a></span>operator()() <span class="overload">[5/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type <a class="el" href="structsigc_1_1hide__functor.html">sigc::hide_functor</a>< 0, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname">, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor, ignoring the 1st argument. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be ignored. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a62027eafacff15f5f7efaefd204f1908"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a62027eafacff15f5f7efaefd204f1908">◆ </a></span>operator()() <span class="overload">[6/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type <a class="el" href="structsigc_1_1hide__functor.html">sigc::hide_functor</a>< 0, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname">, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg6 </td>
+ <td class="paramname"><em>_A_a6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor, ignoring the 1st argument. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be ignored. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+<a id="a599128c72562bd8de98c37f046471080"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a599128c72562bd8de98c37f046471080">◆ </a></span>operator()() <span class="overload">[7/7]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type <a class="el" href="structsigc_1_1hide__functor.html">sigc::hide_functor</a>< 0, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname">, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg6 </td>
+ <td class="paramname"><em>_A_a6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg7 </td>
+ <td class="paramname"><em>_A_a7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Invokes the wrapped functor, ignoring the 1st argument. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_a1</td><td>Argument to be ignored. </td></tr>
+ <tr><td class="paramname">_A_a2</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a3</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a4</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a5</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a6</td><td>Argument to be passed on to the functor. </td></tr>
+ <tr><td class="paramname">_A_a7</td><td>Argument to be passed on to the functor. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>The return value of the functor invocation. </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::hide_functor< 0, T_functor >" name="sigc::hide_functor< 0, T_functor >">
+<area shape="rect" id="node1" title="Adaptor that adds a dummy parameter to the wrapped functor." alt="" coords="32,229,169,271"/>
+<area shape="rect" id="node2" href="$structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="5,155,196,181"/>
+<area shape="rect" id="node3" href="$structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="29,80,173,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="31,5,171,32"/>
+</map>
--- /dev/null
+44ca8d5c3c8b404ce26c67c9d7ebfb6d
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::nil Struct Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1nil.html">nil</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::nil Struct Reference<div class="ingroups"><a class="el" href="group__signal.html">Signals</a> | <a class="el" href="group__sigcfunctors.html">Functors</a> » <a class="el" href="group__slot.html">Slots</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>nil struct type.
+ <a href="structsigc_1_1nil.html#details">More...</a></p>
+
+<p><code>#include <sigc++/functors/functor_trait.h></code></p>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><p>nil struct type. </p>
+<p>The nil struct type is used as default template argument in the unnumbered <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a> and <a class="el" href="classsigc_1_1slot.html" title="Convenience wrapper for the numbered sigc::slot# templates.">sigc::slot</a> templates. </p>
+</div></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1reference__wrapper.html">reference_wrapper</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::reference_wrapper< T_type > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1reference__wrapper.html">sigc::reference_wrapper< T_type ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1reference__wrapper.html#ae0b2f512b6a2555b489ed9dd229efc1c">operator T_type &</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1reference__wrapper.html">sigc::reference_wrapper< T_type ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1reference__wrapper.html#a05dfcad06f2af395c5e2daa9600d455a">reference_wrapper</a>(T_type & v)</td><td class="entry"><a class="el" href="structsigc_1_1reference__wrapper.html">sigc::reference_wrapper< T_type ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1reference__wrapper.html#acf0463810eeadc10cc3dd2eab900145f">value_</a></td><td class="entry"><a class="el" href="structsigc_1_1reference__wrapper.html">sigc::reference_wrapper< T_type ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::reference_wrapper< T_type > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1reference__wrapper.html">reference_wrapper</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="structsigc_1_1reference__wrapper-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::reference_wrapper< T_type > Struct Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Reference wrapper.
+ <a href="structsigc_1_1reference__wrapper.html#details">More...</a></p>
+
+<p><code>#include <sigc++/reference_wrapper.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a05dfcad06f2af395c5e2daa9600d455a"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1reference__wrapper.html#a05dfcad06f2af395c5e2daa9600d455a">reference_wrapper</a> (T_type & v)</td></tr>
+<tr class="separator:a05dfcad06f2af395c5e2daa9600d455a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae0b2f512b6a2555b489ed9dd229efc1c"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1reference__wrapper.html#ae0b2f512b6a2555b489ed9dd229efc1c">operator T_type &</a> () const</td></tr>
+<tr class="separator:ae0b2f512b6a2555b489ed9dd229efc1c"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:acf0463810eeadc10cc3dd2eab900145f"><td class="memItemLeft" align="right" valign="top">T_type & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1reference__wrapper.html#acf0463810eeadc10cc3dd2eab900145f">value_</a></td></tr>
+<tr class="separator:acf0463810eeadc10cc3dd2eab900145f"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_type><br />
+struct sigc::reference_wrapper< T_type ></h3>
+
+<p>Reference wrapper. </p>
+<p>Use <a class="el" href="namespacesigc.html#a48e982c74c057b5630246ba436524041" title="Creates a reference wrapper.">sigc::ref()</a> to create a reference wrapper.</p>
+<dl class="deprecated"><dt><b><a class="el" href="deprecated.html#_deprecated000202">Deprecated:</a></b></dt><dd>Use std::ref() or std::cref() instead to create a <a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a03225.html">std::reference_wrapper()</a>. </dd></dl>
+</div><h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a05dfcad06f2af395c5e2daa9600d455a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a05dfcad06f2af395c5e2daa9600d455a">◆ </a></span>reference_wrapper()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1reference__wrapper.html">sigc::reference_wrapper</a>< T_type >::<a class="el" href="structsigc_1_1reference__wrapper.html">reference_wrapper</a> </td>
+ <td>(</td>
+ <td class="paramtype">T_type & </td>
+ <td class="paramname"><em>v</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="ae0b2f512b6a2555b489ed9dd229efc1c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae0b2f512b6a2555b489ed9dd229efc1c">◆ </a></span>operator T_type &()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1reference__wrapper.html">sigc::reference_wrapper</a>< T_type >::operator T_type & </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="acf0463810eeadc10cc3dd2eab900145f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#acf0463810eeadc10cc3dd2eab900145f">◆ </a></span>value_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">T_type& <a class="el" href="structsigc_1_1reference__wrapper.html">sigc::reference_wrapper</a>< T_type >::value_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1retype__functor.html">sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1retype__functor.html#ace4a0fc864a6417a7cb36adf011177e0">adaptor_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1retype__functor.html">sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a>(const T_functor & _A_functor)</td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1retype__functor.html#a841d7fd2ae795ca4decccca8342e231c">operator()</a>()</td><td class="entry"><a class="el" href="structsigc_1_1retype__functor.html">sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1retype__functor.html#abfd54e4b77096f76bb0e880b6b7b81e1">operator()</a>(T_arg1 _A_a1)</td><td class="entry"><a class="el" href="structsigc_1_1retype__functor.html">sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1retype__functor.html#a6207061ea5a530ca3d37459200ef6864">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2)</td><td class="entry"><a class="el" href="structsigc_1_1retype__functor.html">sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1retype__functor.html#a07b219886709df138ea695049f446215">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)</td><td class="entry"><a class="el" href="structsigc_1_1retype__functor.html">sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1retype__functor.html#a66717878d5c0f2a4cb568c8ff622cb97">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)</td><td class="entry"><a class="el" href="structsigc_1_1retype__functor.html">sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1retype__functor.html#ad60e39d45f35161727c4a57040589816">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)</td><td class="entry"><a class="el" href="structsigc_1_1retype__functor.html">sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1retype__functor.html#a712ff55237e5e0d68195a6d5010f5b3d">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)</td><td class="entry"><a class="el" href="structsigc_1_1retype__functor.html">sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1retype__functor.html#a7b869ff5f806496f7d99f5ae68823291">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)</td><td class="entry"><a class="el" href="structsigc_1_1retype__functor.html">sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1retype__functor.html#a1a594553d0312ca12e1009d179af0dbe">result_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1retype__functor.html">sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1retype__functor.html#a30f35ce3d25b7fd571fbd3ef730de225">retype_functor</a>(type_trait_take_t< T_functor > _A_functor)</td><td class="entry"><a class="el" href="structsigc_1_1retype__functor.html">sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="structsigc_1_1retype__functor-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 > Struct Template Reference<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a> » <a class="el" href="group__retype.html">retype(), retype_return()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Adaptor that performs C-style casts on the parameters passed on to the functor.
+ <a href="structsigc_1_1retype__functor.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/retype.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 >:</div>
+<div class="dyncontent">
+<div class="center"><img src="structsigc_1_1retype__functor__inherit__graph.png" border="0" usemap="#asigc_1_1retype__functor_3_01T__functor_00_01T__type1_00_01T__type2_00_01T__type3_00_01T__type4_00_01T__type5_00_01T__type6_00_01T__type7_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1retype__functor_3_01T__functor_00_01T__type1_00_01T__type2_00_01T__type3_00_01T__type4_00_01T__type5_00_01T__type6_00_01T__type7_01_4_inherit__map" id="asigc_1_1retype__functor_3_01T__functor_00_01T__type1_00_01T__type2_00_01T__type3_00_01T__type4_00_01T__type5_00_01T__type6_00_01T__type7_01_4_inherit__map">
+<area shape="rect" title="Adaptor that performs C-style casts on the parameters passed on to the functor." alt="" coords="5,229,219,300"/>
+<area shape="rect" href="structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="17,155,207,181"/>
+<area shape="rect" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="40,80,184,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="42,5,182,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:ace4a0fc864a6417a7cb36adf011177e0"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adapts.html">adapts</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__functor.html#ace4a0fc864a6417a7cb36adf011177e0">adaptor_type</a></td></tr>
+<tr class="separator:ace4a0fc864a6417a7cb36adf011177e0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1a594553d0312ca12e1009d179af0dbe"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adapts.html">adapts</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__functor.html#a1a594553d0312ca12e1009d179af0dbe">result_type</a></td></tr>
+<tr class="separator:a1a594553d0312ca12e1009d179af0dbe"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td></tr>
+<tr class="separator:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td></tr>
+<tr class="separator:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a30f35ce3d25b7fd571fbd3ef730de225"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__functor.html#a30f35ce3d25b7fd571fbd3ef730de225">retype_functor</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_functor > _A_functor)</td></tr>
+<tr class="memdesc:a30f35ce3d25b7fd571fbd3ef730de225"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">retype_functor</a> object that performs C-style casts on the parameters passed on to the functor. <a href="structsigc_1_1retype__functor.html#a30f35ce3d25b7fd571fbd3ef730de225">More...</a><br /></td></tr>
+<tr class="separator:a30f35ce3d25b7fd571fbd3ef730de225"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a841d7fd2ae795ca4decccca8342e231c"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__functor.html#a841d7fd2ae795ca4decccca8342e231c">operator()</a> ()</td></tr>
+<tr class="separator:a841d7fd2ae795ca4decccca8342e231c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abfd54e4b77096f76bb0e880b6b7b81e1"><td class="memTemplParams" colspan="2">template<class T_arg1 > </td></tr>
+<tr class="memitem:abfd54e4b77096f76bb0e880b6b7b81e1"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__functor.html#abfd54e4b77096f76bb0e880b6b7b81e1">operator()</a> (T_arg1 _A_a1)</td></tr>
+<tr class="separator:abfd54e4b77096f76bb0e880b6b7b81e1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a6207061ea5a530ca3d37459200ef6864"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:a6207061ea5a530ca3d37459200ef6864"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__functor.html#a6207061ea5a530ca3d37459200ef6864">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2)</td></tr>
+<tr class="separator:a6207061ea5a530ca3d37459200ef6864"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a07b219886709df138ea695049f446215"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:a07b219886709df138ea695049f446215"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__functor.html#a07b219886709df138ea695049f446215">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)</td></tr>
+<tr class="separator:a07b219886709df138ea695049f446215"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a66717878d5c0f2a4cb568c8ff622cb97"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:a66717878d5c0f2a4cb568c8ff622cb97"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__functor.html#a66717878d5c0f2a4cb568c8ff622cb97">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)</td></tr>
+<tr class="separator:a66717878d5c0f2a4cb568c8ff622cb97"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad60e39d45f35161727c4a57040589816"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:ad60e39d45f35161727c4a57040589816"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__functor.html#ad60e39d45f35161727c4a57040589816">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)</td></tr>
+<tr class="separator:ad60e39d45f35161727c4a57040589816"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a712ff55237e5e0d68195a6d5010f5b3d"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:a712ff55237e5e0d68195a6d5010f5b3d"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__functor.html#a712ff55237e5e0d68195a6d5010f5b3d">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)</td></tr>
+<tr class="separator:a712ff55237e5e0d68195a6d5010f5b3d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7b869ff5f806496f7d99f5ae68823291"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:a7b869ff5f806496f7d99f5ae68823291"><td class="memTemplItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a>< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::type </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__functor.html#a7b869ff5f806496f7d99f5ae68823291">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)</td></tr>
+<tr class="separator:a7b869ff5f806496f7d99f5ae68823291"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a> (const T_functor & _A_functor)</td></tr>
+<tr class="memdesc:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an adaptor that wraps the passed functor. <a href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">More...</a><br /></td></tr>
+<tr class="separator:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_attribs_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td></tr>
+<tr class="memdesc:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that is invoked from operator()(). <a href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">More...</a><br /></td></tr>
+<tr class="separator:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_functor, class T_type1 = nil, class T_type2 = nil, class T_type3 = nil, class T_type4 = nil, class T_type5 = nil, class T_type6 = nil, class T_type7 = nil><br />
+struct sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 ></h3>
+
+<p>Adaptor that performs C-style casts on the parameters passed on to the functor. </p>
+<p>Use the convenience function <a class="el" href="group__retype.html#ga8b98eeb2a61b5b1f84dcd1d20fe666f1" title="Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed...">sigc::retype()</a> to create an instance of <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">retype_functor</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_functor</em> Type of the functor to wrap.</li>
+<li><em>T_type1</em> Type of <em>T_functor's</em> 1th argument.</li>
+<li><em>T_type2</em> Type of <em>T_functor's</em> 2th argument.</li>
+<li><em>T_type3</em> Type of <em>T_functor's</em> 3th argument.</li>
+<li><em>T_type4</em> Type of <em>T_functor's</em> 4th argument.</li>
+<li><em>T_type5</em> Type of <em>T_functor's</em> 5th argument.</li>
+<li><em>T_type6</em> Type of <em>T_functor's</em> 6th argument.</li>
+<li><em>T_type7</em> Type of <em>T_functor's</em> 7th argument. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="ace4a0fc864a6417a7cb36adf011177e0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ace4a0fc864a6417a7cb36adf011177e0">◆ </a></span>adaptor_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_type1 = nil, class T_type2 = nil, class T_type3 = nil, class T_type4 = nil, class T_type5 = nil, class T_type6 = nil, class T_type7 = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1adapts.html">adapts</a><T_functor>::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> <a class="el" href="structsigc_1_1retype__functor.html">sigc::retype_functor</a>< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a1a594553d0312ca12e1009d179af0dbe"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1a594553d0312ca12e1009d179af0dbe">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_type1 = nil, class T_type2 = nil, class T_type3 = nil, class T_type4 = nil, class T_type5 = nil, class T_type6 = nil, class T_type7 = nil> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1adapts.html">adapts</a><T_functor>::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> <a class="el" href="structsigc_1_1retype__functor.html">sigc::retype_functor</a>< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a30f35ce3d25b7fd571fbd3ef730de225"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a30f35ce3d25b7fd571fbd3ef730de225">◆ </a></span>retype_functor()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_type1 = nil, class T_type2 = nil, class T_type3 = nil, class T_type4 = nil, class T_type5 = nil, class T_type6 = nil, class T_type7 = nil> </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">sigc::retype_functor</a>< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 >::<a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_functor > </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="structsigc_1_1retype__functor.html" title="Adaptor that performs C-style casts on the parameters passed on to the functor.">retype_functor</a> object that performs C-style casts on the parameters passed on to the functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor to invoke from <a class="el" href="structsigc_1_1retype__functor.html#a841d7fd2ae795ca4decccca8342e231c">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a841d7fd2ae795ca4decccca8342e231c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a841d7fd2ae795ca4decccca8342e231c">◆ </a></span>operator()() <span class="overload">[1/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_type1 , class T_type2 , class T_type3 , class T_type4 , class T_type5 , class T_type6 , class T_type7 > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__functor.html">retype_functor</a>< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> <a class="el" href="structsigc_1_1retype__functor.html">sigc::retype_functor</a>< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 >::operator()</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="abfd54e4b77096f76bb0e880b6b7b81e1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abfd54e4b77096f76bb0e880b6b7b81e1">◆ </a></span>operator()() <span class="overload">[2/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_type1 = nil, class T_type2 = nil, class T_type3 = nil, class T_type4 = nil, class T_type5 = nil, class T_type6 = nil, class T_type7 = nil> </div>
+<div class="memtemplate">
+template <class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1>::type <a class="el" href="structsigc_1_1retype__functor.html">sigc::retype_functor</a>< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a6207061ea5a530ca3d37459200ef6864"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a6207061ea5a530ca3d37459200ef6864">◆ </a></span>operator()() <span class="overload">[3/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_type1 = nil, class T_type2 = nil, class T_type3 = nil, class T_type4 = nil, class T_type5 = nil, class T_type6 = nil, class T_type7 = nil> </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2>::type <a class="el" href="structsigc_1_1retype__functor.html">sigc::retype_functor</a>< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a07b219886709df138ea695049f446215"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a07b219886709df138ea695049f446215">◆ </a></span>operator()() <span class="overload">[4/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_type1 = nil, class T_type2 = nil, class T_type3 = nil, class T_type4 = nil, class T_type5 = nil, class T_type6 = nil, class T_type7 = nil> </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3>::type <a class="el" href="structsigc_1_1retype__functor.html">sigc::retype_functor</a>< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a66717878d5c0f2a4cb568c8ff622cb97"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a66717878d5c0f2a4cb568c8ff622cb97">◆ </a></span>operator()() <span class="overload">[5/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_type1 = nil, class T_type2 = nil, class T_type3 = nil, class T_type4 = nil, class T_type5 = nil, class T_type6 = nil, class T_type7 = nil> </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4>::type <a class="el" href="structsigc_1_1retype__functor.html">sigc::retype_functor</a>< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ad60e39d45f35161727c4a57040589816"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad60e39d45f35161727c4a57040589816">◆ </a></span>operator()() <span class="overload">[6/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_type1 = nil, class T_type2 = nil, class T_type3 = nil, class T_type4 = nil, class T_type5 = nil, class T_type6 = nil, class T_type7 = nil> </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type <a class="el" href="structsigc_1_1retype__functor.html">sigc::retype_functor</a>< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a712ff55237e5e0d68195a6d5010f5b3d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a712ff55237e5e0d68195a6d5010f5b3d">◆ </a></span>operator()() <span class="overload">[7/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_type1 = nil, class T_type2 = nil, class T_type3 = nil, class T_type4 = nil, class T_type5 = nil, class T_type6 = nil, class T_type7 = nil> </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type <a class="el" href="structsigc_1_1retype__functor.html">sigc::retype_functor</a>< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg6 </td>
+ <td class="paramname"><em>_A_a6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a7b869ff5f806496f7d99f5ae68823291"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7b869ff5f806496f7d99f5ae68823291">◆ </a></span>operator()() <span class="overload">[8/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor , class T_type1 = nil, class T_type2 = nil, class T_type3 = nil, class T_type4 = nil, class T_type5 = nil, class T_type6 = nil, class T_type7 = nil> </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1deduce__result__type.html">deduce_result_type</a><T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type <a class="el" href="structsigc_1_1retype__functor.html">sigc::retype_functor</a>< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg6 </td>
+ <td class="paramname"><em>_A_a6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg7 </td>
+ <td class="paramname"><em>_A_a7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 >" name="sigc::retype_functor< T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 >">
+<area shape="rect" id="node1" title="Adaptor that performs C-style casts on the parameters passed on to the functor." alt="" coords="5,229,219,300"/>
+<area shape="rect" id="node2" href="$structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="17,155,207,181"/>
+<area shape="rect" id="node3" href="$structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="40,80,184,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="42,5,182,32"/>
+</map>
--- /dev/null
+9379051e1fe7a24e23eff7917d014ea0
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1retype__return__functor.html">retype_return_functor</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::retype_return_functor< T_return, T_functor > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor< T_return, T_functor ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a>(const T_functor & _A_functor)</td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor.html#a4cf9725b7ac4fdfeded4ab3f56d61a88">operator()</a>()</td><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor< T_return, T_functor ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor.html#aa6beb1654c027400d852e2df0fafb6aa">operator()</a>(T_arg1 _A_a1)</td><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor< T_return, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor.html#a1352125cef26032af138aa2a327f8f66">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2)</td><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor< T_return, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor.html#a0bcbf84c24c2195626bf4e6a2d1353b1">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)</td><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor< T_return, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor.html#a7e3b161bfa746f69a2af64a00af7cbd2">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)</td><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor< T_return, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor.html#a741b3fd8c423d3e63bdefa810e65ef44">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)</td><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor< T_return, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor.html#ab6c4d0b29bbcbca2e64db8249db54171">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)</td><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor< T_return, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor.html#a68bdb4e6cf7d505f210017ab744603f0">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)</td><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor< T_return, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor.html#aa8421dc266ad653de395e7d01e631fdc">result_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor< T_return, T_functor ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor.html#aa9546db86a6d1cfa7224a3a0cbad4827">retype_return_functor</a>()</td><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor< T_return, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor.html#a9ebfb2a6cfb5125b0705c0adef2cbfb8">retype_return_functor</a>(type_trait_take_t< T_functor > _A_functor)</td><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor< T_return, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::retype_return_functor< T_return, T_functor > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1retype__return__functor.html">retype_return_functor</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="structsigc_1_1retype__return__functor-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::retype_return_functor< T_return, T_functor > Struct Template Reference<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a> » <a class="el" href="group__retype.html">retype(), retype_return()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Adaptor that performs a C-style cast on the return value of a functor.
+ <a href="structsigc_1_1retype__return__functor.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/retype_return.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::retype_return_functor< T_return, T_functor >:</div>
+<div class="dyncontent">
+<div class="center"><img src="structsigc_1_1retype__return__functor__inherit__graph.png" border="0" usemap="#asigc_1_1retype__return__functor_3_01T__return_00_01T__functor_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1retype__return__functor_3_01T__return_00_01T__functor_01_4_inherit__map" id="asigc_1_1retype__return__functor_3_01T__return_00_01T__functor_01_4_inherit__map">
+<area shape="rect" title="Adaptor that performs a C-style cast on the return value of a functor." alt="" coords="27,229,175,285"/>
+<area shape="rect" href="structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="5,155,196,181"/>
+<area shape="rect" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="29,80,173,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="31,5,171,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:aa8421dc266ad653de395e7d01e631fdc"><td class="memItemLeft" align="right" valign="top">typedef T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__return__functor.html#aa8421dc266ad653de395e7d01e631fdc">result_type</a></td></tr>
+<tr class="separator:aa8421dc266ad653de395e7d01e631fdc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td></tr>
+<tr class="separator:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td></tr>
+<tr class="separator:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:aa9546db86a6d1cfa7224a3a0cbad4827"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__return__functor.html#aa9546db86a6d1cfa7224a3a0cbad4827">retype_return_functor</a> ()</td></tr>
+<tr class="separator:aa9546db86a6d1cfa7224a3a0cbad4827"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9ebfb2a6cfb5125b0705c0adef2cbfb8"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__return__functor.html#a9ebfb2a6cfb5125b0705c0adef2cbfb8">retype_return_functor</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_functor > _A_functor)</td></tr>
+<tr class="memdesc:a9ebfb2a6cfb5125b0705c0adef2cbfb8"><td class="mdescLeft"> </td><td class="mdescRight">Constructs a <a class="el" href="structsigc_1_1retype__return__functor.html" title="Adaptor that performs a C-style cast on the return value of a functor.">retype_return_functor</a> object that perform a C-style cast on the return value of the passed functor. <a href="structsigc_1_1retype__return__functor.html#a9ebfb2a6cfb5125b0705c0adef2cbfb8">More...</a><br /></td></tr>
+<tr class="separator:a9ebfb2a6cfb5125b0705c0adef2cbfb8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4cf9725b7ac4fdfeded4ab3f56d61a88"><td class="memItemLeft" align="right" valign="top">T_return </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__return__functor.html#a4cf9725b7ac4fdfeded4ab3f56d61a88">operator()</a> ()</td></tr>
+<tr class="separator:a4cf9725b7ac4fdfeded4ab3f56d61a88"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa6beb1654c027400d852e2df0fafb6aa"><td class="memTemplParams" colspan="2">template<class T_arg1 > </td></tr>
+<tr class="memitem:aa6beb1654c027400d852e2df0fafb6aa"><td class="memTemplItemLeft" align="right" valign="top">T_return </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__return__functor.html#aa6beb1654c027400d852e2df0fafb6aa">operator()</a> (T_arg1 _A_a1)</td></tr>
+<tr class="separator:aa6beb1654c027400d852e2df0fafb6aa"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1352125cef26032af138aa2a327f8f66"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:a1352125cef26032af138aa2a327f8f66"><td class="memTemplItemLeft" align="right" valign="top">T_return </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__return__functor.html#a1352125cef26032af138aa2a327f8f66">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2)</td></tr>
+<tr class="separator:a1352125cef26032af138aa2a327f8f66"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0bcbf84c24c2195626bf4e6a2d1353b1"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:a0bcbf84c24c2195626bf4e6a2d1353b1"><td class="memTemplItemLeft" align="right" valign="top">T_return </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__return__functor.html#a0bcbf84c24c2195626bf4e6a2d1353b1">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)</td></tr>
+<tr class="separator:a0bcbf84c24c2195626bf4e6a2d1353b1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7e3b161bfa746f69a2af64a00af7cbd2"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:a7e3b161bfa746f69a2af64a00af7cbd2"><td class="memTemplItemLeft" align="right" valign="top">T_return </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__return__functor.html#a7e3b161bfa746f69a2af64a00af7cbd2">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)</td></tr>
+<tr class="separator:a7e3b161bfa746f69a2af64a00af7cbd2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a741b3fd8c423d3e63bdefa810e65ef44"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:a741b3fd8c423d3e63bdefa810e65ef44"><td class="memTemplItemLeft" align="right" valign="top">T_return </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__return__functor.html#a741b3fd8c423d3e63bdefa810e65ef44">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)</td></tr>
+<tr class="separator:a741b3fd8c423d3e63bdefa810e65ef44"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab6c4d0b29bbcbca2e64db8249db54171"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:ab6c4d0b29bbcbca2e64db8249db54171"><td class="memTemplItemLeft" align="right" valign="top">T_return </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__return__functor.html#ab6c4d0b29bbcbca2e64db8249db54171">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)</td></tr>
+<tr class="separator:ab6c4d0b29bbcbca2e64db8249db54171"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a68bdb4e6cf7d505f210017ab744603f0"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:a68bdb4e6cf7d505f210017ab744603f0"><td class="memTemplItemLeft" align="right" valign="top">T_return </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__return__functor.html#a68bdb4e6cf7d505f210017ab744603f0">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)</td></tr>
+<tr class="separator:a68bdb4e6cf7d505f210017ab744603f0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a> (const T_functor & _A_functor)</td></tr>
+<tr class="memdesc:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an adaptor that wraps the passed functor. <a href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">More...</a><br /></td></tr>
+<tr class="separator:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_attribs_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td></tr>
+<tr class="memdesc:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that is invoked from operator()(). <a href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">More...</a><br /></td></tr>
+<tr class="separator:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_return, class T_functor><br />
+struct sigc::retype_return_functor< T_return, T_functor ></h3>
+
+<p>Adaptor that performs a C-style cast on the return value of a functor. </p>
+<p>Use the convenience function <a class="el" href="group__retype.html#ga23a8cdbc12c57fbef0866b5c51d71588" title="Creates an adaptor of type sigc::retype_return_functor which performs a C-style cast on the return va...">sigc::retype_return()</a> to create an instance of <a class="el" href="structsigc_1_1retype__return__functor.html" title="Adaptor that performs a C-style cast on the return value of a functor.">retype_return_functor</a>.</p>
+<p>The following template arguments are used:</p><ul>
+<li><em>T_return</em> Target type of the C-style cast.</li>
+<li><em>T_functor</em> Type of the functor to wrap. </li>
+</ul>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="aa8421dc266ad653de395e7d01e631fdc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa8421dc266ad653de395e7d01e631fdc">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_functor > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_return <a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor</a>< T_return, T_functor >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="aa9546db86a6d1cfa7224a3a0cbad4827"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa9546db86a6d1cfa7224a3a0cbad4827">◆ </a></span>retype_return_functor() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor</a>< T_return, T_functor >::<a class="el" href="structsigc_1_1retype__return__functor.html">retype_return_functor</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a9ebfb2a6cfb5125b0705c0adef2cbfb8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9ebfb2a6cfb5125b0705c0adef2cbfb8">◆ </a></span>retype_return_functor() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor</a>< T_return, T_functor >::<a class="el" href="structsigc_1_1retype__return__functor.html">retype_return_functor</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_functor > </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Constructs a <a class="el" href="structsigc_1_1retype__return__functor.html" title="Adaptor that performs a C-style cast on the return value of a functor.">retype_return_functor</a> object that perform a C-style cast on the return value of the passed functor. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">_A_functor</td><td>Functor to invoke from <a class="el" href="structsigc_1_1retype__return__functor.html#a4cf9725b7ac4fdfeded4ab3f56d61a88">operator()()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a4cf9725b7ac4fdfeded4ab3f56d61a88"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4cf9725b7ac4fdfeded4ab3f56d61a88">◆ </a></span>operator()() <span class="overload">[1/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_functor > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor</a>< T_return, T_functor >::operator()</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aa6beb1654c027400d852e2df0fafb6aa"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa6beb1654c027400d852e2df0fafb6aa">◆ </a></span>operator()() <span class="overload">[2/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor</a>< T_return, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a1352125cef26032af138aa2a327f8f66"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1352125cef26032af138aa2a327f8f66">◆ </a></span>operator()() <span class="overload">[3/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor</a>< T_return, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a0bcbf84c24c2195626bf4e6a2d1353b1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0bcbf84c24c2195626bf4e6a2d1353b1">◆ </a></span>operator()() <span class="overload">[4/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor</a>< T_return, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a7e3b161bfa746f69a2af64a00af7cbd2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7e3b161bfa746f69a2af64a00af7cbd2">◆ </a></span>operator()() <span class="overload">[5/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor</a>< T_return, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a741b3fd8c423d3e63bdefa810e65ef44"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a741b3fd8c423d3e63bdefa810e65ef44">◆ </a></span>operator()() <span class="overload">[6/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor</a>< T_return, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ab6c4d0b29bbcbca2e64db8249db54171"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab6c4d0b29bbcbca2e64db8249db54171">◆ </a></span>operator()() <span class="overload">[7/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor</a>< T_return, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg6 </td>
+ <td class="paramname"><em>_A_a6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a68bdb4e6cf7d505f210017ab744603f0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a68bdb4e6cf7d505f210017ab744603f0">◆ </a></span>operator()() <span class="overload">[8/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_return , class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">T_return <a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor</a>< T_return, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg6 </td>
+ <td class="paramname"><em>_A_a6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg7 </td>
+ <td class="paramname"><em>_A_a7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html">retype_return_functor< void, T_functor ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::retype_return_functor< void, T_functor > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html">sigc::retype_return_functor< void, T_functor ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a>(const T_functor & _A_functor)</td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td><td class="entry"><a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td><td class="entry"><span class="mlabel">mutable</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#af181f5a8134c5a834e2ad0ed7590fbfe">operator()</a>()</td><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html">sigc::retype_return_functor< void, T_functor ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#a2ad16a9f8f247e6f7661838fb084ffd0">operator()</a>(T_arg1 _A_a1)</td><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html">sigc::retype_return_functor< void, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#abf17761c3eefdb3167a8562f009a8491">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2)</td><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html">sigc::retype_return_functor< void, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#adb392f4717b522668eb5236dbaf48e68">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)</td><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html">sigc::retype_return_functor< void, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#a2c32e33b12c18d0533d4305ddd98dabe">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)</td><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html">sigc::retype_return_functor< void, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#a24d383a5100302678a9a18dc5a138e51">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)</td><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html">sigc::retype_return_functor< void, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#af0c3d23d0216aa0631720eb00ca8f7ef">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)</td><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html">sigc::retype_return_functor< void, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#a73a475fd2fe5e4d9e184ca5092b0ced4">operator()</a>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)</td><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html">sigc::retype_return_functor< void, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#a64bccc59fc20fdf0fd80281597d350b2">result_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html">sigc::retype_return_functor< void, T_functor ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#a720e802de29a72d1e15626b1719844bc">retype_return_functor</a>()</td><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html">sigc::retype_return_functor< void, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#acd4789babb601ac5bee163651d89f3c8">retype_return_functor</a>(type_trait_take_t< T_functor > _A_functor)</td><td class="entry"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html">sigc::retype_return_functor< void, T_functor ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::retype_return_functor< void, T_functor > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html">retype_return_functor< void, T_functor ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::retype_return_functor< void, T_functor > Struct Template Reference<div class="ingroups"><a class="el" href="group__adaptors.html">Adaptors</a> » <a class="el" href="group__retype.html">retype(), retype_return()</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Adaptor that performs a C-style cast on the return value of a functor.
+ <a href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#details">More...</a></p>
+
+<p><code>#include <sigc++/adaptors/retype_return.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::retype_return_functor< void, T_functor >:</div>
+<div class="dyncontent">
+<div class="center"><img src="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4__inherit__graph.png" border="0" usemap="#asigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4_inherit__map" id="asigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4_inherit__map">
+<area shape="rect" title="Adaptor that performs a C-style cast on the return value of a functor." alt="" coords="5,229,208,271"/>
+<area shape="rect" href="structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="11,155,202,181"/>
+<area shape="rect" href="structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="35,80,179,107"/>
+<area shape="rect" href="structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="37,5,177,32"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a64bccc59fc20fdf0fd80281597d350b2"><td class="memItemLeft" align="right" valign="top">typedef void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#a64bccc59fc20fdf0fd80281597d350b2">result_type</a></td></tr>
+<tr class="separator:a64bccc59fc20fdf0fd80281597d350b2"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a></td></tr>
+<tr class="separator:a5c3f3b614455552f4cd5d88b1f330248 inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1adaptor__trait.html">adaptor_trait</a>< T_functor >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td></tr>
+<tr class="separator:a914e75556dae1fdcf0162c4c99aca79d inherit pub_types_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a720e802de29a72d1e15626b1719844bc"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#a720e802de29a72d1e15626b1719844bc">retype_return_functor</a> ()</td></tr>
+<tr class="separator:a720e802de29a72d1e15626b1719844bc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:acd4789babb601ac5bee163651d89f3c8"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#acd4789babb601ac5bee163651d89f3c8">retype_return_functor</a> (<a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_functor > _A_functor)</td></tr>
+<tr class="separator:acd4789babb601ac5bee163651d89f3c8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af181f5a8134c5a834e2ad0ed7590fbfe"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#af181f5a8134c5a834e2ad0ed7590fbfe">operator()</a> ()</td></tr>
+<tr class="separator:af181f5a8134c5a834e2ad0ed7590fbfe"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2ad16a9f8f247e6f7661838fb084ffd0"><td class="memTemplParams" colspan="2">template<class T_arg1 > </td></tr>
+<tr class="memitem:a2ad16a9f8f247e6f7661838fb084ffd0"><td class="memTemplItemLeft" align="right" valign="top">void </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#a2ad16a9f8f247e6f7661838fb084ffd0">operator()</a> (T_arg1 _A_a1)</td></tr>
+<tr class="separator:a2ad16a9f8f247e6f7661838fb084ffd0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abf17761c3eefdb3167a8562f009a8491"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 > </td></tr>
+<tr class="memitem:abf17761c3eefdb3167a8562f009a8491"><td class="memTemplItemLeft" align="right" valign="top">void </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#abf17761c3eefdb3167a8562f009a8491">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2)</td></tr>
+<tr class="separator:abf17761c3eefdb3167a8562f009a8491"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adb392f4717b522668eb5236dbaf48e68"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 > </td></tr>
+<tr class="memitem:adb392f4717b522668eb5236dbaf48e68"><td class="memTemplItemLeft" align="right" valign="top">void </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#adb392f4717b522668eb5236dbaf48e68">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)</td></tr>
+<tr class="separator:adb392f4717b522668eb5236dbaf48e68"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2c32e33b12c18d0533d4305ddd98dabe"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </td></tr>
+<tr class="memitem:a2c32e33b12c18d0533d4305ddd98dabe"><td class="memTemplItemLeft" align="right" valign="top">void </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#a2c32e33b12c18d0533d4305ddd98dabe">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)</td></tr>
+<tr class="separator:a2c32e33b12c18d0533d4305ddd98dabe"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24d383a5100302678a9a18dc5a138e51"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </td></tr>
+<tr class="memitem:a24d383a5100302678a9a18dc5a138e51"><td class="memTemplItemLeft" align="right" valign="top">void </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#a24d383a5100302678a9a18dc5a138e51">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)</td></tr>
+<tr class="separator:a24d383a5100302678a9a18dc5a138e51"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af0c3d23d0216aa0631720eb00ca8f7ef"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </td></tr>
+<tr class="memitem:af0c3d23d0216aa0631720eb00ca8f7ef"><td class="memTemplItemLeft" align="right" valign="top">void </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#af0c3d23d0216aa0631720eb00ca8f7ef">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)</td></tr>
+<tr class="separator:af0c3d23d0216aa0631720eb00ca8f7ef"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a73a475fd2fe5e4d9e184ca5092b0ced4"><td class="memTemplParams" colspan="2">template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </td></tr>
+<tr class="memitem:a73a475fd2fe5e4d9e184ca5092b0ced4"><td class="memTemplItemLeft" align="right" valign="top">void </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#a73a475fd2fe5e4d9e184ca5092b0ced4">operator()</a> (T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)</td></tr>
+<tr class="separator:a73a475fd2fe5e4d9e184ca5092b0ced4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">adapts</a> (const T_functor & _A_functor)</td></tr>
+<tr class="memdesc:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Constructs an adaptor that wraps the passed functor. <a href="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8">More...</a><br /></td></tr>
+<tr class="separator:a947b69ccbdcabd4ef4163dcab96096f8 inherit pub_methods_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
+Additional Inherited Members</h2></td></tr>
+<tr class="inherit_header pub_attribs_structsigc_1_1adapts"><td colspan="2" onclick="javascript:toggleInherit('pub_attribs_structsigc_1_1adapts')"><img src="closed.png" alt="-"/> Public Attributes inherited from <a class="el" href="structsigc_1_1adapts.html">sigc::adapts< T_functor ></a></td></tr>
+<tr class="memitem:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248">adaptor_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">functor_</a></td></tr>
+<tr class="memdesc:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="mdescLeft"> </td><td class="mdescRight">Adaptor that is invoked from operator()(). <a href="structsigc_1_1adapts.html#a2f4b37eb160708baf17de57f2abce7a7">More...</a><br /></td></tr>
+<tr class="separator:a2f4b37eb160708baf17de57f2abce7a7 inherit pub_attribs_structsigc_1_1adapts"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_functor><br />
+struct sigc::retype_return_functor< void, T_functor ></h3>
+
+<p>Adaptor that performs a C-style cast on the return value of a functor. </p>
+<p>This template specialization is for a void return. It drops the return value of the functor it invokes. Use the convenience function <a class="el" href="group__hide.html#gae4e6f5491471c12440f1c5d480726b98" title="Creates an adaptor of type sigc::retype_return_functor which drops the return value of the passed fun...">sigc::hide_return()</a> to create an instance of sigc::retype_return_functor<void>. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a64bccc59fc20fdf0fd80281597d350b2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a64bccc59fc20fdf0fd80281597d350b2">◆ </a></span>result_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef void <a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor</a>< void, T_functor >::<a class="el" href="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d">result_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a720e802de29a72d1e15626b1719844bc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a720e802de29a72d1e15626b1719844bc">◆ </a></span>retype_return_functor() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor</a>< void, T_functor >::<a class="el" href="structsigc_1_1retype__return__functor.html">retype_return_functor</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="acd4789babb601ac5bee163651d89f3c8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#acd4789babb601ac5bee163651d89f3c8">◆ </a></span>retype_return_functor() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor</a>< void, T_functor >::<a class="el" href="structsigc_1_1retype__return__functor.html">retype_return_functor</a> </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e">type_trait_take_t</a>< T_functor > </td>
+ <td class="paramname"><em>_A_functor</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="af181f5a8134c5a834e2ad0ed7590fbfe"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af181f5a8134c5a834e2ad0ed7590fbfe">◆ </a></span>operator()() <span class="overload">[1/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">void <a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor</a>< void, T_functor >::operator()</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a2ad16a9f8f247e6f7661838fb084ffd0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2ad16a9f8f247e6f7661838fb084ffd0">◆ </a></span>operator()() <span class="overload">[2/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">void <a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor</a>< void, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="abf17761c3eefdb3167a8562f009a8491"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abf17761c3eefdb3167a8562f009a8491">◆ </a></span>operator()() <span class="overload">[3/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">void <a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor</a>< void, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="adb392f4717b522668eb5236dbaf48e68"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#adb392f4717b522668eb5236dbaf48e68">◆ </a></span>operator()() <span class="overload">[4/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">void <a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor</a>< void, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a2c32e33b12c18d0533d4305ddd98dabe"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2c32e33b12c18d0533d4305ddd98dabe">◆ </a></span>operator()() <span class="overload">[5/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">void <a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor</a>< void, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a24d383a5100302678a9a18dc5a138e51"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a24d383a5100302678a9a18dc5a138e51">◆ </a></span>operator()() <span class="overload">[6/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">void <a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor</a>< void, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="af0c3d23d0216aa0631720eb00ca8f7ef"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af0c3d23d0216aa0631720eb00ca8f7ef">◆ </a></span>operator()() <span class="overload">[7/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">void <a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor</a>< void, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg6 </td>
+ <td class="paramname"><em>_A_a6</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a73a475fd2fe5e4d9e184ca5092b0ced4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a73a475fd2fe5e4d9e184ca5092b0ced4">◆ </a></span>operator()() <span class="overload">[8/8]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">void <a class="el" href="structsigc_1_1retype__return__functor.html">sigc::retype_return_functor</a>< void, T_functor >::operator() </td>
+ <td>(</td>
+ <td class="paramtype">T_arg1 </td>
+ <td class="paramname"><em>_A_a1</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg2 </td>
+ <td class="paramname"><em>_A_a2</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg3 </td>
+ <td class="paramname"><em>_A_a3</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg4 </td>
+ <td class="paramname"><em>_A_a4</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg5 </td>
+ <td class="paramname"><em>_A_a5</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg6 </td>
+ <td class="paramname"><em>_A_a6</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">T_arg7 </td>
+ <td class="paramname"><em>_A_a7</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:58 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::retype_return_functor< void, T_functor >" name="sigc::retype_return_functor< void, T_functor >">
+<area shape="rect" id="node1" title="Adaptor that performs a C-style cast on the return value of a functor." alt="" coords="5,229,208,271"/>
+<area shape="rect" id="node2" href="$structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="11,155,202,181"/>
+<area shape="rect" id="node3" href="$structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="35,80,179,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="37,5,177,32"/>
+</map>
--- /dev/null
+8f7b6834e696714550be7ebcb0108eb6
\ No newline at end of file
--- /dev/null
+<map id="sigc::retype_return_functor< T_return, T_functor >" name="sigc::retype_return_functor< T_return, T_functor >">
+<area shape="rect" id="node1" title="Adaptor that performs a C-style cast on the return value of a functor." alt="" coords="27,229,175,285"/>
+<area shape="rect" id="node2" href="$structsigc_1_1adapts.html" title="Base type for adaptors." alt="" coords="5,155,196,181"/>
+<area shape="rect" id="node3" href="$structsigc_1_1adaptor__base.html" title="A hint to the compiler." alt="" coords="29,80,173,107"/>
+<area shape="rect" id="node4" href="$structsigc_1_1functor__base.html" title="A hint to the compiler." alt="" coords="31,5,171,32"/>
+</map>
--- /dev/null
+38965f2998bcc34f0a0360dec626f820
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::signal_base Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a>(bool should_block=true) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a>(const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a>(slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a>(iterator_type i)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">mutable</span><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a>(iterator_type i, const slot_base & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a>(iterator_type i, slot_base && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a>(const signal_base & src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">sigc::trackable::operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">sigc::trackable::operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a>(const signal_base & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a>(signal_base && src)</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a>() const noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a>()</td><td class="entry"><a class="el" href="structsigc_1_1signal__base.html">sigc::signal_base</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::signal_base Struct Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-types">Protected Types</a> |
+<a href="#pro-methods">Protected Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="structsigc_1_1signal__base-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::signal_base Struct Reference<div class="ingroups"><a class="el" href="group__signal.html">Signals</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Base class for the <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates.
+ <a href="structsigc_1_1signal__base.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal_base.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::signal_base:</div>
+<div class="dyncontent">
+<div class="center"><img src="structsigc_1_1signal__base__inherit__graph.png" border="0" usemap="#asigc_1_1signal__base_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1signal__base_inherit__map" id="asigc_1_1signal__base_inherit__map">
+<area shape="rect" title="Base class for the sigc::signal# templates." alt="" coords="169,1317,303,1343"/>
+<area shape="rect" href="classsigc_1_1signal0.html" title=" " alt="" coords="383,123,559,164"/>
+<area shape="rect" href="classsigc_1_1signal0.html" title=" " alt="" coords="383,224,559,265"/>
+<area shape="rect" href="classsigc_1_1signal1.html" title=" " alt="" coords="383,371,559,412"/>
+<area shape="rect" href="classsigc_1_1signal1.html" title=" " alt="" coords="377,616,566,657"/>
+<area shape="rect" href="classsigc_1_1signal2.html" title=" " alt="" coords="351,759,592,800"/>
+<area shape="rect" href="classsigc_1_1signal2.html" title=" " alt="" coords="383,868,559,909"/>
+<area shape="rect" href="classsigc_1_1signal3.html" title=" " alt="" coords="382,1065,561,1121"/>
+<area shape="rect" href="classsigc_1_1signal3.html" title=" " alt="" coords="382,1182,561,1238"/>
+<area shape="rect" href="classsigc_1_1signal4.html" title=" " alt="" coords="382,1302,561,1358"/>
+<area shape="rect" href="classsigc_1_1signal4.html" title=" " alt="" coords="377,1386,566,1442"/>
+<area shape="rect" href="classsigc_1_1signal5.html" title=" " alt="" coords="351,1521,592,1577"/>
+<area shape="rect" href="classsigc_1_1signal5.html" title=" " alt="" coords="382,1710,561,1766"/>
+<area shape="rect" href="classsigc_1_1signal6.html" title=" " alt="" coords="382,1791,561,1861"/>
+<area shape="rect" href="classsigc_1_1signal6.html" title=" " alt="" coords="365,1886,578,1942"/>
+<area shape="rect" href="classsigc_1_1signal7.html" title=" " alt="" coords="383,1966,559,2022"/>
+<area shape="rect" href="classsigc_1_1signal7.html" title=" " alt="" coords="377,2047,566,2117"/>
+<area shape="rect" href="classsigc_1_1signal7.html" title=" " alt="" coords="382,2141,561,2212"/>
+<area shape="rect" href="structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="5,1317,121,1343"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal0 template." alt="" coords="647,5,908,47"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal0 template." alt="" coords="691,71,864,141"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="685,166,870,193"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal0 template." alt="" coords="693,217,861,273"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="695,297,859,339"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal1 template." alt="" coords="693,363,861,419"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal1 template." alt="" coords="688,443,867,499"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal1 template." alt="" coords="679,524,876,595"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal2 template." alt="" coords="662,619,893,675"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal2 template." alt="" coords="661,700,893,771"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="695,795,859,836"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal2 template." alt="" coords="693,861,861,917"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal3 template." alt="" coords="652,941,903,997"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html" title="Convenience wrapper for the numbered sigc::signal3 template." alt="" coords="667,1021,888,1092"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="682,1116,873,1157"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal3 template." alt="" coords="688,1182,867,1238"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="688,1262,867,1318"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal4 template." alt="" coords="688,1342,867,1398"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal4 template." alt="" coords="683,1423,872,1493"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html" title="Convenience wrapper for the numbered sigc::signal4 template." alt="" coords="657,1517,897,1588"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal5 template." alt="" coords="662,1612,893,1683"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html" title="Convenience wrapper for the numbered sigc::signal5 template." alt="" coords="650,1707,905,1777"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="688,1802,867,1858"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal5 template." alt="" coords="685,1882,870,1938"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html" title="Convenience wrapper for the numbered sigc::signal6 template." alt="" coords="652,1963,903,2033"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html" title="Convenience wrapper for the numbered sigc::signal6 template." alt="" coords="640,2057,915,2128"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="682,2153,873,2209"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal6 template." alt="" coords="671,2233,884,2289"/>
+<area shape="rect" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates." alt="" coords="688,2313,867,2384"/>
+<area shape="rect" href="classsigc_1_1signal_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal# templates." alt="" coords="677,2409,877,2494"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:aa60e22abd088b6cde2dd50fb3f228aa4"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a></td></tr>
+<tr class="separator:aa60e22abd088b6cde2dd50fb3f228aa4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_types_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_types_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Types inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed inherit pub_types_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:aff65198ddcb4fbccb644ff853e663e0e"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e">signal_base</a> () noexcept</td></tr>
+<tr class="separator:aff65198ddcb4fbccb644ff853e663e0e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a761e95b8c7b460664d3338ed3eb39543"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543">signal_base</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src) noexcept</td></tr>
+<tr class="separator:a761e95b8c7b460664d3338ed3eb39543"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9f8570c89cd5c0b35613570a5ea80154"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154">signal_base</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a9f8570c89cd5c0b35613570a5ea80154"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afa2e5807537c989b430015e5ae05a357"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357">~signal_base</a> ()</td></tr>
+<tr class="separator:afa2e5807537c989b430015e5ae05a357"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a52fda4806ec9dbc02baa95ce70c13fb0"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">block</a> (bool should_block=true) noexcept</td></tr>
+<tr class="memdesc:a52fda4806ec9dbc02baa95ce70c13fb0"><td class="mdescLeft"> </td><td class="mdescRight">Sets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0">More...</a><br /></td></tr>
+<tr class="separator:a52fda4806ec9dbc02baa95ce70c13fb0"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a228da4dd1eac6905dafbc5697086e503"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">blocked</a> () const noexcept</td></tr>
+<tr class="memdesc:a228da4dd1eac6905dafbc5697086e503"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether all slots in the list are blocked. <a href="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503">More...</a><br /></td></tr>
+<tr class="separator:a228da4dd1eac6905dafbc5697086e503"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a17597d66e680d222248c523985f0afd6"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">clear</a> ()</td></tr>
+<tr class="memdesc:a17597d66e680d222248c523985f0afd6"><td class="mdescLeft"> </td><td class="mdescRight">Empties the list of slots. <a href="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6">More...</a><br /></td></tr>
+<tr class="separator:a17597d66e680d222248c523985f0afd6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a24e7fc4e07ac19cebafe8e3bd71bfe94"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">empty</a> () const noexcept</td></tr>
+<tr class="memdesc:a24e7fc4e07ac19cebafe8e3bd71bfe94"><td class="mdescLeft"> </td><td class="mdescRight">Returns whether the list of slots is empty. <a href="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94">More...</a><br /></td></tr>
+<tr class="separator:a24e7fc4e07ac19cebafe8e3bd71bfe94"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a90b36a7b33e107ce0af0de895e0df286"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286">operator=</a> (const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & src)</td></tr>
+<tr class="separator:a90b36a7b33e107ce0af0de895e0df286"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a277a34edf44207fb4784807eac5872c6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6">operator=</a> (<a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && src)</td></tr>
+<tr class="separator:a277a34edf44207fb4784807eac5872c6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0725416f747d6db3c57fa318a9f887a8"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">size</a> () const noexcept</td></tr>
+<tr class="memdesc:a0725416f747d6db3c57fa318a9f887a8"><td class="mdescLeft"> </td><td class="mdescRight">Returns the number of slots in the list. <a href="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8">More...</a><br /></td></tr>
+<tr class="separator:a0725416f747d6db3c57fa318a9f887a8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aebb7ac69ea745cd60c0505f8d553d27f"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">unblock</a> () noexcept</td></tr>
+<tr class="memdesc:aebb7ac69ea745cd60c0505f8d553d27f"><td class="mdescLeft"> </td><td class="mdescRight">Unsets the blocking state of all slots in the list. <a href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f">More...</a><br /></td></tr>
+<tr class="separator:aebb7ac69ea745cd60c0505f8d553d27f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="inherit_header pub_methods_structsigc_1_1trackable"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_structsigc_1_1trackable')"><img src="closed.png" alt="-"/> Public Member Functions inherited from <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5 inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff inherit pub_methods_structsigc_1_1trackable"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-types"></a>
+Protected Types</h2></td></tr>
+<tr class="memitem:a328b132e5dfb99dbc3aae1e5c3bb0981"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a></td></tr>
+<tr class="separator:a328b132e5dfb99dbc3aae1e5c3bb0981"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-methods"></a>
+Protected Member Functions</h2></td></tr>
+<tr class="memitem:a5c89a76a27d69c512f554b841b1bd08a"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">connect</a> (const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a5c89a76a27d69c512f554b841b1bd08a"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a">More...</a><br /></td></tr>
+<tr class="separator:a5c89a76a27d69c512f554b841b1bd08a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a50eab6d37728bbbf3beb21d684a72e6c"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">connect</a> (<a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:a50eab6d37728bbbf3beb21d684a72e6c"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the end of the list of slots. <a href="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c">More...</a><br /></td></tr>
+<tr class="separator:a50eab6d37728bbbf3beb21d684a72e6c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a21efc57eea29c3139855909ad4807984"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">erase</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i)</td></tr>
+<tr class="memdesc:a21efc57eea29c3139855909ad4807984"><td class="mdescLeft"> </td><td class="mdescRight">Removes the slot at the given position from the list of slots. <a href="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984">More...</a><br /></td></tr>
+<tr class="separator:a21efc57eea29c3139855909ad4807984"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0527d817989f2386556ce164c3adfa7"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">impl</a> () const</td></tr>
+<tr class="memdesc:ab0527d817989f2386556ce164c3adfa7"><td class="mdescLeft"> </td><td class="mdescRight">Returns the signal_impl object encapsulating the list of slots. <a href="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7">More...</a><br /></td></tr>
+<tr class="separator:ab0527d817989f2386556ce164c3adfa7"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87da23ad801faa9e2b6b4be2a747e757"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & slot_)</td></tr>
+<tr class="memdesc:a87da23ad801faa9e2b6b4be2a747e757"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757">More...</a><br /></td></tr>
+<tr class="separator:a87da23ad801faa9e2b6b4be2a747e757"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa80c33868910139dd2f511afcc31b687"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">insert</a> (<a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> i, <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && slot_)</td></tr>
+<tr class="memdesc:aa80c33868910139dd2f511afcc31b687"><td class="mdescLeft"> </td><td class="mdescRight">Adds a slot at the given position into the list of slots. <a href="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687">More...</a><br /></td></tr>
+<tr class="separator:aa80c33868910139dd2f511afcc31b687"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:a747d448c28fd256ef580d165eb69f17a"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">impl_</a></td></tr>
+<tr class="memdesc:a747d448c28fd256ef580d165eb69f17a"><td class="mdescLeft"> </td><td class="mdescRight">The signal_impl object encapsulating the slot list. <a href="structsigc_1_1signal__base.html#a747d448c28fd256ef580d165eb69f17a">More...</a><br /></td></tr>
+<tr class="separator:a747d448c28fd256ef580d165eb69f17a"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><p>Base class for the <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates. </p>
+<p><a class="el" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates.">signal_base</a> integrates most of the interface of the derived <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># templates. The implementation, however, resides in sigc::internal::signal_impl. A sigc::internal::signal_impl object is dynamically allocated from <a class="el" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates.">signal_base</a> when first connecting a slot to the signal. This ensures that empty signals don't waste memory.</p>
+<p>sigc::internal::signal_impl is reference-counted. When a <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># object is copied, the reference count of its sigc::internal::signal_impl object is incremented. Both <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a># objects then refer to the same sigc::internal::signal_impl object.</p>
+<p>Deleting the signal during emission, e.g. from one of its slots, may result in memory leaks. This drawback is fixed in version 3 of libsigc++. A workaround is to make a copy of the signal during the emission: </p><div class="fragment"><div class="line"><a class="code" href="classsigc_1_1signal.html">sigc::signal</a><...> sig2(*p_sig);</div>
+<div class="line">p_sig->emit();</div>
+<div class="ttc" id="aclasssigc_1_1signal_html"><div class="ttname"><a href="classsigc_1_1signal.html">sigc::signal</a></div><div class="ttdoc">Convenience wrapper for the numbered sigc::signal# templates.</div><div class="ttdef"><b>Definition:</b> signal.h:4015</div></div>
+</div><!-- fragment --><p> This is not very costly. A sigc::signal<> is not much more than a pointer to a sigc::internal::signal_impl instance, which is not copied. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a328b132e5dfb99dbc3aae1e5c3bb0981"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a328b132e5dfb99dbc3aae1e5c3bb0981">◆ </a></span>iterator_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> <a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">sigc::signal_base::iterator_type</a></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aa60e22abd088b6cde2dd50fb3f228aa4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa60e22abd088b6cde2dd50fb3f228aa4">◆ </a></span>size_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef std::size_t <a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">sigc::signal_base::size_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="aff65198ddcb4fbccb644ff853e663e0e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aff65198ddcb4fbccb644ff853e663e0e">◆ </a></span>signal_base() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">sigc::signal_base::signal_base </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">noexcept</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a761e95b8c7b460664d3338ed3eb39543"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a761e95b8c7b460664d3338ed3eb39543">◆ </a></span>signal_base() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">sigc::signal_base::signal_base </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">noexcept</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a9f8570c89cd5c0b35613570a5ea80154"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9f8570c89cd5c0b35613570a5ea80154">◆ </a></span>signal_base() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname">sigc::signal_base::signal_base </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="afa2e5807537c989b430015e5ae05a357"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#afa2e5807537c989b430015e5ae05a357">◆ </a></span>~signal_base()</h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname">sigc::signal_base::~signal_base </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a52fda4806ec9dbc02baa95ce70c13fb0"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a52fda4806ec9dbc02baa95ce70c13fb0">◆ </a></span>block()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">void sigc::signal_base::block </td>
+ <td>(</td>
+ <td class="paramtype">bool </td>
+ <td class="paramname"><em>should_block</em> = <code>true</code></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">noexcept</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Sets the blocking state of all slots in the list. </p>
+<p>If <em>should_block</em> is <code>true</code> then the blocking state is set. Subsequent emissions of the signal don't invoke the functors contained in the slots until <a class="el" href="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f" title="Unsets the blocking state of all slots in the list.">unblock()</a> or <a class="el" href="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0" title="Sets the blocking state of all slots in the list.">block()</a> with <em>should_block</em> = <code>false</code> is called. <a class="el" href="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9" title="Sets the blocking state.">sigc::slot_base::block()</a> and <a class="el" href="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d" title="Unsets the blocking state.">sigc::slot_base::unblock()</a> can change the blocking state of individual slots. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">should_block</td><td>Indicates whether the blocking state should be set or unset.</td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="since_2_4"><dt><b><a class="el" href="since_2_4.html#_since_2_4000019">Since libsigc++ 2.4:</a></b></dt><dd></dd></dl>
+
+</div>
+</div>
+<a id="a228da4dd1eac6905dafbc5697086e503"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a228da4dd1eac6905dafbc5697086e503">◆ </a></span>blocked()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">bool sigc::signal_base::blocked </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">noexcept</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Returns whether all slots in the list are blocked. </p>
+<dl class="section return"><dt>Returns</dt><dd><code>true</code> if all slots are blocked or the list is empty.</dd></dl>
+<dl class="since_2_4"><dt><b><a class="el" href="since_2_4.html#_since_2_4000018">Since libsigc++ 2.4:</a></b></dt><dd></dd></dl>
+
+</div>
+</div>
+<a id="a17597d66e680d222248c523985f0afd6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a17597d66e680d222248c523985f0afd6">◆ </a></span>clear()</h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname">void sigc::signal_base::clear </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+<p>Empties the list of slots. </p>
+
+</div>
+</div>
+<a id="a5c89a76a27d69c512f554b841b1bd08a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5c89a76a27d69c512f554b841b1bd08a">◆ </a></span>connect() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> sigc::signal_base::connect </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td>
+ <td class="paramname"><em>slot_</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Adds a slot at the end of the list of slots. </p>
+<p>With <a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a" title="Adds a slot at the end of the list of slots.">connect()</a>, slots can also be added during signal emission. In this case, they won't be executed until the next emission occurs. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">slot_</td><td>The slot to add to the list of slots. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>An iterator pointing to the new slot in the list. </dd></dl>
+
+</div>
+</div>
+<a id="a50eab6d37728bbbf3beb21d684a72e6c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a50eab6d37728bbbf3beb21d684a72e6c">◆ </a></span>connect() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> sigc::signal_base::connect </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && </td>
+ <td class="paramname"><em>slot_</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Adds a slot at the end of the list of slots. </p>
+<p>With <a class="el" href="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a" title="Adds a slot at the end of the list of slots.">connect()</a>, slots can also be added during signal emission. In this case, they won't be executed until the next emission occurs. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">slot_</td><td>The slot to add to the list of slots. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>An iterator pointing to the new slot in the list.</dd></dl>
+<dl class="since_2_8"><dt><b><a class="el" href="since_2_8.html#_since_2_8000011">Since libsigc++ 2.8:</a></b></dt><dd></dd></dl>
+
+</div>
+</div>
+<a id="a24e7fc4e07ac19cebafe8e3bd71bfe94"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a24e7fc4e07ac19cebafe8e3bd71bfe94">◆ </a></span>empty()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">bool sigc::signal_base::empty </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">noexcept</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Returns whether the list of slots is empty. </p>
+<dl class="section return"><dt>Returns</dt><dd><code>true</code> if the list of slots is empty. </dd></dl>
+
+</div>
+</div>
+<a id="a21efc57eea29c3139855909ad4807984"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a21efc57eea29c3139855909ad4807984">◆ </a></span>erase()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> sigc::signal_base::erase </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td>
+ <td class="paramname"><em>i</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Removes the slot at the given position from the list of slots. </p>
+<p>Note that this function does not work during signal emission! </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">i</td><td>An iterator pointing to the slot to be removed. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>An iterator pointing to the slot in the list after the one removed. </dd></dl>
+
+</div>
+</div>
+<a id="ab0527d817989f2386556ce164c3adfa7"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab0527d817989f2386556ce164c3adfa7">◆ </a></span>impl()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">internal::signal_impl* sigc::signal_base::impl </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Returns the signal_impl object encapsulating the list of slots. </p>
+<dl class="section return"><dt>Returns</dt><dd>The signal_impl object encapsulating the list of slots. </dd></dl>
+
+</div>
+</div>
+<a id="a87da23ad801faa9e2b6b4be2a747e757"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a87da23ad801faa9e2b6b4be2a747e757">◆ </a></span>insert() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> sigc::signal_base::insert </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td>
+ <td class="paramname"><em>i</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const <a class="el" href="classsigc_1_1slot__base.html">slot_base</a> & </td>
+ <td class="paramname"><em>slot_</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Adds a slot at the given position into the list of slots. </p>
+<p>Note that this function does not work during signal emission! </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">i</td><td>An iterator indicating the position where <em>slot_</em> should be inserted. </td></tr>
+ <tr><td class="paramname">slot_</td><td>The slot to add to the list of slots. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>An iterator pointing to the new slot in the list. </dd></dl>
+
+</div>
+</div>
+<a id="aa80c33868910139dd2f511afcc31b687"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa80c33868910139dd2f511afcc31b687">◆ </a></span>insert() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> sigc::signal_base::insert </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981">iterator_type</a> </td>
+ <td class="paramname"><em>i</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="classsigc_1_1slot__base.html">slot_base</a> && </td>
+ <td class="paramname"><em>slot_</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Adds a slot at the given position into the list of slots. </p>
+<p>Note that this function does not work during signal emission! </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">i</td><td>An iterator indicating the position where <em>slot_</em> should be inserted. </td></tr>
+ <tr><td class="paramname">slot_</td><td>The slot to add to the list of slots. </td></tr>
+ </table>
+ </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>An iterator pointing to the new slot in the list.</dd></dl>
+<dl class="since_2_8"><dt><b><a class="el" href="since_2_8.html#_since_2_8000012">Since libsigc++ 2.8:</a></b></dt><dd></dd></dl>
+
+</div>
+</div>
+<a id="a90b36a7b33e107ce0af0de895e0df286"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a90b36a7b33e107ce0af0de895e0df286">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a>& sigc::signal_base::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="structsigc_1_1signal__base.html">signal_base</a> & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a277a34edf44207fb4784807eac5872c6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a277a34edf44207fb4784807eac5872c6">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a>& sigc::signal_base::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="structsigc_1_1signal__base.html">signal_base</a> && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a0725416f747d6db3c57fa318a9f887a8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0725416f747d6db3c57fa318a9f887a8">◆ </a></span>size()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4">size_type</a> sigc::signal_base::size </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">noexcept</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Returns the number of slots in the list. </p>
+<dl class="section return"><dt>Returns</dt><dd>The number of slots in the list. </dd></dl>
+
+</div>
+</div>
+<a id="aebb7ac69ea745cd60c0505f8d553d27f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aebb7ac69ea745cd60c0505f8d553d27f">◆ </a></span>unblock()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">void sigc::signal_base::unblock </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">noexcept</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>Unsets the blocking state of all slots in the list. </p>
+<dl class="since_2_4"><dt><b><a class="el" href="since_2_4.html#_since_2_4000020">Since libsigc++ 2.4:</a></b></dt><dd></dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a747d448c28fd256ef580d165eb69f17a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a747d448c28fd256ef580d165eb69f17a">◆ </a></span>impl_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">internal::signal_impl* sigc::signal_base::impl_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">mutable</span><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+<p>The signal_impl object encapsulating the slot list. </p>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::signal_base" name="sigc::signal_base">
+<area shape="rect" id="node1" title="Base class for the sigc::signal# templates." alt="" coords="169,1317,303,1343"/>
+<area shape="rect" id="node3" href="$classsigc_1_1signal0.html" title=" " alt="" coords="383,123,559,164"/>
+<area shape="rect" id="node6" href="$classsigc_1_1signal0.html" title=" " alt="" coords="383,224,559,265"/>
+<area shape="rect" id="node9" href="$classsigc_1_1signal1.html" title=" " alt="" coords="383,371,559,412"/>
+<area shape="rect" id="node12" href="$classsigc_1_1signal1.html" title=" " alt="" coords="377,616,566,657"/>
+<area shape="rect" id="node15" href="$classsigc_1_1signal2.html" title=" " alt="" coords="351,759,592,800"/>
+<area shape="rect" id="node18" href="$classsigc_1_1signal2.html" title=" " alt="" coords="383,868,559,909"/>
+<area shape="rect" id="node21" href="$classsigc_1_1signal3.html" title=" " alt="" coords="382,1065,561,1121"/>
+<area shape="rect" id="node24" href="$classsigc_1_1signal3.html" title=" " alt="" coords="382,1182,561,1238"/>
+<area shape="rect" id="node27" href="$classsigc_1_1signal4.html" title=" " alt="" coords="382,1302,561,1358"/>
+<area shape="rect" id="node30" href="$classsigc_1_1signal4.html" title=" " alt="" coords="377,1386,566,1442"/>
+<area shape="rect" id="node33" href="$classsigc_1_1signal5.html" title=" " alt="" coords="351,1521,592,1577"/>
+<area shape="rect" id="node36" href="$classsigc_1_1signal5.html" title=" " alt="" coords="382,1710,561,1766"/>
+<area shape="rect" id="node39" href="$classsigc_1_1signal6.html" title=" " alt="" coords="382,1791,561,1861"/>
+<area shape="rect" id="node42" href="$classsigc_1_1signal6.html" title=" " alt="" coords="365,1886,578,1942"/>
+<area shape="rect" id="node45" href="$classsigc_1_1signal7.html" title=" " alt="" coords="383,1966,559,2022"/>
+<area shape="rect" id="node47" href="$classsigc_1_1signal7.html" title=" " alt="" coords="377,2047,566,2117"/>
+<area shape="rect" id="node49" href="$classsigc_1_1signal7.html" title=" " alt="" coords="382,2141,561,2212"/>
+<area shape="rect" id="node2" href="$structsigc_1_1trackable.html" title="Base class for objects with auto-disconnection." alt="" coords="5,1317,121,1343"/>
+<area shape="rect" id="node4" href="$classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal0 template." alt="" coords="647,5,908,47"/>
+<area shape="rect" id="node5" href="$classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal0 template." alt="" coords="691,71,864,141"/>
+<area shape="rect" id="node7" href="$classsigc_1_1signal_3_01T__return_07_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="685,166,870,193"/>
+<area shape="rect" id="node8" href="$classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal0 template." alt="" coords="693,217,861,273"/>
+<area shape="rect" id="node10" href="$classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="695,297,859,339"/>
+<area shape="rect" id="node11" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal1 template." alt="" coords="693,363,861,419"/>
+<area shape="rect" id="node13" href="$classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal1 template." alt="" coords="688,443,867,499"/>
+<area shape="rect" id="node14" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal1 template." alt="" coords="679,524,876,595"/>
+<area shape="rect" id="node16" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal2 template." alt="" coords="662,619,893,675"/>
+<area shape="rect" id="node17" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal2 template." alt="" coords="661,700,893,771"/>
+<area shape="rect" id="node19" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="695,795,859,836"/>
+<area shape="rect" id="node20" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal2 template." alt="" coords="693,861,861,917"/>
+<area shape="rect" id="node22" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal3 template." alt="" coords="652,941,903,997"/>
+<area shape="rect" id="node23" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html" title="Convenience wrapper for the numbered sigc::signal3 template." alt="" coords="667,1021,888,1092"/>
+<area shape="rect" id="node25" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="682,1116,873,1157"/>
+<area shape="rect" id="node26" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal3 template." alt="" coords="688,1182,867,1238"/>
+<area shape="rect" id="node28" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="688,1262,867,1318"/>
+<area shape="rect" id="node29" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal4 template." alt="" coords="688,1342,867,1398"/>
+<area shape="rect" id="node31" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal4 template." alt="" coords="683,1423,872,1493"/>
+<area shape="rect" id="node32" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html" title="Convenience wrapper for the numbered sigc::signal4 template." alt="" coords="657,1517,897,1588"/>
+<area shape="rect" id="node34" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal5 template." alt="" coords="662,1612,893,1683"/>
+<area shape="rect" id="node35" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html" title="Convenience wrapper for the numbered sigc::signal5 template." alt="" coords="650,1707,905,1777"/>
+<area shape="rect" id="node37" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="688,1802,867,1858"/>
+<area shape="rect" id="node38" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal5 template." alt="" coords="685,1882,870,1938"/>
+<area shape="rect" id="node40" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html" title="Convenience wrapper for the numbered sigc::signal6 template." alt="" coords="652,1963,903,2033"/>
+<area shape="rect" id="node41" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html" title="Convenience wrapper for the numbered sigc::signal6 template." alt="" coords="640,2057,915,2128"/>
+<area shape="rect" id="node43" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="682,2153,873,2209"/>
+<area shape="rect" id="node44" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal6 template." alt="" coords="671,2233,884,2289"/>
+<area shape="rect" id="node46" href="$classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates." alt="" coords="688,2313,867,2384"/>
+<area shape="rect" id="node48" href="$classsigc_1_1signal_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal# templates." alt="" coords="677,2409,877,2494"/>
+</map>
--- /dev/null
+e2beb28f287897839bdad326bfc5ae1f
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1slot__const__iterator.html">slot_const_iterator</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::slot_const_iterator< T_slot > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator< T_slot ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html#ac111b0a48ab96f75e720f32171072bc5">difference_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator< T_slot ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html#a5e8020f4f1c3da18fcac4c9babee306f">i_</a></td><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator< T_slot ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html#afc9dff16373a2fa7a4f373bd48a852c6">iterator_category</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator< T_slot ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html#a3466a35177b6a0999a12ff0ee10e91b9">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator< T_slot ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html#a0139736ee01df37af11f3551d76a2b53">operator!=</a>(const slot_const_iterator & other) const</td><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html#a37c9a5d5bba252e41a628bd1c87fd883">operator*</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html#aed166d716b032a781d2169c919cefdc9">operator++</a>()</td><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html#aa2f7b6d4c7aa7192fca0bdcc08b74ba6">operator++</a>(int)</td><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html#a1c1d7d7798914c80d6a60d87c4b24c0a">operator--</a>()</td><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html#a9ece84f63e078754915dcc6dc6ee1cc4">operator--</a>(int)</td><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html#afd0ff56e0779787da2c7dfdb0ef4630c">operator-></a>() const</td><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html#af88c3fcadb7ce415fcad4bd5dafad087">operator==</a>(const slot_const_iterator & other) const</td><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html#a28f3f0d2ac11dd8805d75682d8f38022">pointer</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator< T_slot ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html#a8300967b4b29096e7ad0b96db04e095a">reference</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator< T_slot ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html#adb1eeabfa619cbd9565aa0f9429ca5ed">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator< T_slot ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html#a2b9e80b87a3400bb6f794c07f90d2d47">slot_const_iterator</a>()</td><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html#af84ef3ee54ae482534d88ac6a5b871ae">slot_const_iterator</a>(const iterator_type & i)</td><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html#ae377905cad9a91ca23d09877c72d82cd">slot_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator< T_slot ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html#a20a9337066a01a137ea9945bdd509e80">value_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator< T_slot ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::slot_const_iterator< T_slot > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1slot__const__iterator.html">slot_const_iterator</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="structsigc_1_1slot__const__iterator-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::slot_const_iterator< T_slot > Struct Template Reference<div class="ingroups"><a class="el" href="group__signal.html">Signals</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>STL-style const iterator for <a class="el" href="structsigc_1_1slot__list.html" title="STL-style list interface for sigc::signal#.">slot_list</a>.
+ <a href="structsigc_1_1slot__const__iterator.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:ac111b0a48ab96f75e720f32171072bc5"><td class="memItemLeft" align="right" valign="top">typedef std::ptrdiff_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__const__iterator.html#ac111b0a48ab96f75e720f32171072bc5">difference_type</a></td></tr>
+<tr class="separator:ac111b0a48ab96f75e720f32171072bc5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afc9dff16373a2fa7a4f373bd48a852c6"><td class="memItemLeft" align="right" valign="top">typedef <a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a07517.html">std::bidirectional_iterator_tag</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__const__iterator.html#afc9dff16373a2fa7a4f373bd48a852c6">iterator_category</a></td></tr>
+<tr class="separator:afc9dff16373a2fa7a4f373bd48a852c6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3466a35177b6a0999a12ff0ee10e91b9"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__const__iterator.html">internal::signal_impl::const_iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__const__iterator.html#a3466a35177b6a0999a12ff0ee10e91b9">iterator_type</a></td></tr>
+<tr class="separator:a3466a35177b6a0999a12ff0ee10e91b9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a28f3f0d2ac11dd8805d75682d8f38022"><td class="memItemLeft" align="right" valign="top">typedef const T_slot * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__const__iterator.html#a28f3f0d2ac11dd8805d75682d8f38022">pointer</a></td></tr>
+<tr class="separator:a28f3f0d2ac11dd8805d75682d8f38022"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8300967b4b29096e7ad0b96db04e095a"><td class="memItemLeft" align="right" valign="top">typedef const T_slot & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__const__iterator.html#a8300967b4b29096e7ad0b96db04e095a">reference</a></td></tr>
+<tr class="separator:a8300967b4b29096e7ad0b96db04e095a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:adb1eeabfa619cbd9565aa0f9429ca5ed"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__const__iterator.html#adb1eeabfa619cbd9565aa0f9429ca5ed">size_type</a></td></tr>
+<tr class="separator:adb1eeabfa619cbd9565aa0f9429ca5ed"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae377905cad9a91ca23d09877c72d82cd"><td class="memItemLeft" align="right" valign="top">typedef T_slot </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__const__iterator.html#ae377905cad9a91ca23d09877c72d82cd">slot_type</a></td></tr>
+<tr class="separator:ae377905cad9a91ca23d09877c72d82cd"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a20a9337066a01a137ea9945bdd509e80"><td class="memItemLeft" align="right" valign="top">typedef T_slot </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__const__iterator.html#a20a9337066a01a137ea9945bdd509e80">value_type</a></td></tr>
+<tr class="separator:a20a9337066a01a137ea9945bdd509e80"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a2b9e80b87a3400bb6f794c07f90d2d47"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__const__iterator.html#a2b9e80b87a3400bb6f794c07f90d2d47">slot_const_iterator</a> ()</td></tr>
+<tr class="separator:a2b9e80b87a3400bb6f794c07f90d2d47"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af84ef3ee54ae482534d88ac6a5b871ae"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__const__iterator.html#af84ef3ee54ae482534d88ac6a5b871ae">slot_const_iterator</a> (const <a class="el" href="structsigc_1_1slot__const__iterator.html#a3466a35177b6a0999a12ff0ee10e91b9">iterator_type</a> & i)</td></tr>
+<tr class="separator:af84ef3ee54ae482534d88ac6a5b871ae"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0139736ee01df37af11f3551d76a2b53"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__const__iterator.html#a0139736ee01df37af11f3551d76a2b53">operator!=</a> (const <a class="el" href="structsigc_1_1slot__const__iterator.html">slot_const_iterator</a> & other) const</td></tr>
+<tr class="separator:a0139736ee01df37af11f3551d76a2b53"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a37c9a5d5bba252e41a628bd1c87fd883"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__const__iterator.html#a8300967b4b29096e7ad0b96db04e095a">reference</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__const__iterator.html#a37c9a5d5bba252e41a628bd1c87fd883">operator*</a> () const</td></tr>
+<tr class="separator:a37c9a5d5bba252e41a628bd1c87fd883"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed166d716b032a781d2169c919cefdc9"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__const__iterator.html">slot_const_iterator</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__const__iterator.html#aed166d716b032a781d2169c919cefdc9">operator++</a> ()</td></tr>
+<tr class="separator:aed166d716b032a781d2169c919cefdc9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa2f7b6d4c7aa7192fca0bdcc08b74ba6"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__const__iterator.html">slot_const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__const__iterator.html#aa2f7b6d4c7aa7192fca0bdcc08b74ba6">operator++</a> (int)</td></tr>
+<tr class="separator:aa2f7b6d4c7aa7192fca0bdcc08b74ba6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1c1d7d7798914c80d6a60d87c4b24c0a"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__const__iterator.html">slot_const_iterator</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__const__iterator.html#a1c1d7d7798914c80d6a60d87c4b24c0a">operator--</a> ()</td></tr>
+<tr class="separator:a1c1d7d7798914c80d6a60d87c4b24c0a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9ece84f63e078754915dcc6dc6ee1cc4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__const__iterator.html">slot_const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__const__iterator.html#a9ece84f63e078754915dcc6dc6ee1cc4">operator--</a> (int)</td></tr>
+<tr class="separator:a9ece84f63e078754915dcc6dc6ee1cc4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afd0ff56e0779787da2c7dfdb0ef4630c"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__const__iterator.html#a28f3f0d2ac11dd8805d75682d8f38022">pointer</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__const__iterator.html#afd0ff56e0779787da2c7dfdb0ef4630c">operator-></a> () const</td></tr>
+<tr class="separator:afd0ff56e0779787da2c7dfdb0ef4630c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af88c3fcadb7ce415fcad4bd5dafad087"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__const__iterator.html#af88c3fcadb7ce415fcad4bd5dafad087">operator==</a> (const <a class="el" href="structsigc_1_1slot__const__iterator.html">slot_const_iterator</a> & other) const</td></tr>
+<tr class="separator:af88c3fcadb7ce415fcad4bd5dafad087"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:a5e8020f4f1c3da18fcac4c9babee306f"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__const__iterator.html#a3466a35177b6a0999a12ff0ee10e91b9">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__const__iterator.html#a5e8020f4f1c3da18fcac4c9babee306f">i_</a></td></tr>
+<tr class="separator:a5e8020f4f1c3da18fcac4c9babee306f"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<typename T_slot><br />
+struct sigc::slot_const_iterator< T_slot ></h3>
+
+<p>STL-style const iterator for <a class="el" href="structsigc_1_1slot__list.html" title="STL-style list interface for sigc::signal#.">slot_list</a>. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="ac111b0a48ab96f75e720f32171072bc5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac111b0a48ab96f75e720f32171072bc5">◆ </a></span>difference_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef std::ptrdiff_t <a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator</a>< T_slot >::<a class="el" href="structsigc_1_1slot__const__iterator.html#ac111b0a48ab96f75e720f32171072bc5">difference_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="afc9dff16373a2fa7a4f373bd48a852c6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#afc9dff16373a2fa7a4f373bd48a852c6">◆ </a></span>iterator_category</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a07517.html">std::bidirectional_iterator_tag</a> <a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator</a>< T_slot >::<a class="el" href="structsigc_1_1slot__const__iterator.html#afc9dff16373a2fa7a4f373bd48a852c6">iterator_category</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a3466a35177b6a0999a12ff0ee10e91b9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3466a35177b6a0999a12ff0ee10e91b9">◆ </a></span>iterator_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__const__iterator.html">internal::signal_impl::const_iterator_type</a> <a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator</a>< T_slot >::<a class="el" href="structsigc_1_1slot__const__iterator.html#a3466a35177b6a0999a12ff0ee10e91b9">iterator_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a28f3f0d2ac11dd8805d75682d8f38022"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a28f3f0d2ac11dd8805d75682d8f38022">◆ </a></span>pointer</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef const T_slot* <a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator</a>< T_slot >::<a class="el" href="structsigc_1_1slot__const__iterator.html#a28f3f0d2ac11dd8805d75682d8f38022">pointer</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a8300967b4b29096e7ad0b96db04e095a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8300967b4b29096e7ad0b96db04e095a">◆ </a></span>reference</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef const T_slot& <a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator</a>< T_slot >::<a class="el" href="structsigc_1_1slot__const__iterator.html#a8300967b4b29096e7ad0b96db04e095a">reference</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="adb1eeabfa619cbd9565aa0f9429ca5ed"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#adb1eeabfa619cbd9565aa0f9429ca5ed">◆ </a></span>size_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef std::size_t <a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator</a>< T_slot >::<a class="el" href="structsigc_1_1slot__const__iterator.html#adb1eeabfa619cbd9565aa0f9429ca5ed">size_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ae377905cad9a91ca23d09877c72d82cd"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae377905cad9a91ca23d09877c72d82cd">◆ </a></span>slot_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_slot <a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator</a>< T_slot >::<a class="el" href="structsigc_1_1slot__const__iterator.html#ae377905cad9a91ca23d09877c72d82cd">slot_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a20a9337066a01a137ea9945bdd509e80"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a20a9337066a01a137ea9945bdd509e80">◆ </a></span>value_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_slot <a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator</a>< T_slot >::<a class="el" href="structsigc_1_1slot__const__iterator.html#a20a9337066a01a137ea9945bdd509e80">value_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a2b9e80b87a3400bb6f794c07f90d2d47"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2b9e80b87a3400bb6f794c07f90d2d47">◆ </a></span>slot_const_iterator() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator</a>< T_slot >::<a class="el" href="structsigc_1_1slot__const__iterator.html">slot_const_iterator</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="af84ef3ee54ae482534d88ac6a5b871ae"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af84ef3ee54ae482534d88ac6a5b871ae">◆ </a></span>slot_const_iterator() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator</a>< T_slot >::<a class="el" href="structsigc_1_1slot__const__iterator.html">slot_const_iterator</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="structsigc_1_1slot__const__iterator.html#a3466a35177b6a0999a12ff0ee10e91b9">iterator_type</a> & </td>
+ <td class="paramname"><em>i</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a0139736ee01df37af11f3551d76a2b53"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0139736ee01df37af11f3551d76a2b53">◆ </a></span>operator!=()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">bool <a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator</a>< T_slot >::<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01568.html#ga8ae9cabed8e455713324dacd39bedef1">operator!</a>= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="structsigc_1_1slot__const__iterator.html">slot_const_iterator</a>< T_slot > & </td>
+ <td class="paramname"><em>other</em></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a37c9a5d5bba252e41a628bd1c87fd883"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a37c9a5d5bba252e41a628bd1c87fd883">◆ </a></span>operator*()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__const__iterator.html#a8300967b4b29096e7ad0b96db04e095a">reference</a> <a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator</a>< T_slot >::operator* </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aed166d716b032a781d2169c919cefdc9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aed166d716b032a781d2169c919cefdc9">◆ </a></span>operator++() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__const__iterator.html">slot_const_iterator</a>& <a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator</a>< T_slot >::operator++ </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aa2f7b6d4c7aa7192fca0bdcc08b74ba6"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa2f7b6d4c7aa7192fca0bdcc08b74ba6">◆ </a></span>operator++() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__const__iterator.html">slot_const_iterator</a> <a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator</a>< T_slot >::operator++ </td>
+ <td>(</td>
+ <td class="paramtype">int </td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a1c1d7d7798914c80d6a60d87c4b24c0a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1c1d7d7798914c80d6a60d87c4b24c0a">◆ </a></span>operator--() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__const__iterator.html">slot_const_iterator</a>& <a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator</a>< T_slot >::operator-- </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a9ece84f63e078754915dcc6dc6ee1cc4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9ece84f63e078754915dcc6dc6ee1cc4">◆ </a></span>operator--() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__const__iterator.html">slot_const_iterator</a> <a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator</a>< T_slot >::operator-- </td>
+ <td>(</td>
+ <td class="paramtype">int </td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="afd0ff56e0779787da2c7dfdb0ef4630c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#afd0ff56e0779787da2c7dfdb0ef4630c">◆ </a></span>operator->()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__const__iterator.html#a28f3f0d2ac11dd8805d75682d8f38022">pointer</a> <a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator</a>< T_slot >::operator-> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="af88c3fcadb7ce415fcad4bd5dafad087"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af88c3fcadb7ce415fcad4bd5dafad087">◆ </a></span>operator==()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">bool <a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator</a>< T_slot >::operator== </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="structsigc_1_1slot__const__iterator.html">slot_const_iterator</a>< T_slot > & </td>
+ <td class="paramname"><em>other</em></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a5e8020f4f1c3da18fcac4c9babee306f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5e8020f4f1c3da18fcac4c9babee306f">◆ </a></span>i_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__const__iterator.html#a3466a35177b6a0999a12ff0ee10e91b9">iterator_type</a> <a class="el" href="structsigc_1_1slot__const__iterator.html">sigc::slot_const_iterator</a>< T_slot >::i_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1slot__iterator.html">slot_iterator</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::slot_iterator< T_slot > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator< T_slot ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html#adb6307ee06c592d67ecef0607f319d5e">difference_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator< T_slot ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html#a5e113a9e58ce7e16a11838a203b72649">i_</a></td><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator< T_slot ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html#a0c882521b418b9faaac879a1d337ace5">iterator_category</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator< T_slot ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html#a189fa620b9d90dc1a224d9ad91da5011">iterator_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator< T_slot ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html#a880c8929759eca2fc7fb55cb0c813c55">operator!=</a>(const slot_iterator & other) const</td><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html#aa01dddd6f7b4e1a726a55cd1d430f398">operator*</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html#af5a3b852c1c6e8f69c41f64a17204758">operator++</a>()</td><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html#a7469f1ad5f1802d7a04f031ee4b3e54e">operator++</a>(int)</td><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html#a8aeef4e41dc0930beaa8d6a37b27775c">operator--</a>()</td><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html#afd2ebfa71c2df96290f2bce0746d6fa5">operator--</a>(int)</td><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html#a0a77bd2eccf05cecbdf3b690c5301540">operator-></a>() const</td><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html#af2b4e16f15258f6cd98f8049afd0b88d">operator==</a>(const slot_iterator & other) const</td><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html#afb36f2add6064e0d7e7ae63ee2ddcde9">pointer</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator< T_slot ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html#aa3e69a557b73d817a1951af1b1767632">reference</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator< T_slot ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html#a1dd8ea0a80b5bb0f936833a1c2e363ed">size_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator< T_slot ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html#a82d4023ad9dc38dcde4cae6bf65cd8c8">slot_iterator</a>()</td><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html#a07933d72e788285673121e5ce019a260">slot_iterator</a>(const iterator_type & i)</td><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html#af7a0ed93fca0064021d77275305e04a9">slot_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator< T_slot ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html#a94f7fcbd3224e1f7e88b84f9e326b0b3">value_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator< T_slot ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::slot_iterator< T_slot > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1slot__iterator.html">slot_iterator</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pub-attribs">Public Attributes</a> |
+<a href="structsigc_1_1slot__iterator-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::slot_iterator< T_slot > Struct Template Reference<div class="ingroups"><a class="el" href="group__signal.html">Signals</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>STL-style iterator for <a class="el" href="structsigc_1_1slot__list.html" title="STL-style list interface for sigc::signal#.">slot_list</a>.
+ <a href="structsigc_1_1slot__iterator.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:adb6307ee06c592d67ecef0607f319d5e"><td class="memItemLeft" align="right" valign="top">typedef std::ptrdiff_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__iterator.html#adb6307ee06c592d67ecef0607f319d5e">difference_type</a></td></tr>
+<tr class="separator:adb6307ee06c592d67ecef0607f319d5e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0c882521b418b9faaac879a1d337ace5"><td class="memItemLeft" align="right" valign="top">typedef <a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a07517.html">std::bidirectional_iterator_tag</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__iterator.html#a0c882521b418b9faaac879a1d337ace5">iterator_category</a></td></tr>
+<tr class="separator:a0c882521b418b9faaac879a1d337ace5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a189fa620b9d90dc1a224d9ad91da5011"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__iterator.html#a189fa620b9d90dc1a224d9ad91da5011">iterator_type</a></td></tr>
+<tr class="separator:a189fa620b9d90dc1a224d9ad91da5011"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afb36f2add6064e0d7e7ae63ee2ddcde9"><td class="memItemLeft" align="right" valign="top">typedef T_slot * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__iterator.html#afb36f2add6064e0d7e7ae63ee2ddcde9">pointer</a></td></tr>
+<tr class="separator:afb36f2add6064e0d7e7ae63ee2ddcde9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa3e69a557b73d817a1951af1b1767632"><td class="memItemLeft" align="right" valign="top">typedef T_slot & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__iterator.html#aa3e69a557b73d817a1951af1b1767632">reference</a></td></tr>
+<tr class="separator:aa3e69a557b73d817a1951af1b1767632"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1dd8ea0a80b5bb0f936833a1c2e363ed"><td class="memItemLeft" align="right" valign="top">typedef std::size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__iterator.html#a1dd8ea0a80b5bb0f936833a1c2e363ed">size_type</a></td></tr>
+<tr class="separator:a1dd8ea0a80b5bb0f936833a1c2e363ed"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af7a0ed93fca0064021d77275305e04a9"><td class="memItemLeft" align="right" valign="top">typedef T_slot </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__iterator.html#af7a0ed93fca0064021d77275305e04a9">slot_type</a></td></tr>
+<tr class="separator:af7a0ed93fca0064021d77275305e04a9"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a94f7fcbd3224e1f7e88b84f9e326b0b3"><td class="memItemLeft" align="right" valign="top">typedef T_slot </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__iterator.html#a94f7fcbd3224e1f7e88b84f9e326b0b3">value_type</a></td></tr>
+<tr class="separator:a94f7fcbd3224e1f7e88b84f9e326b0b3"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a82d4023ad9dc38dcde4cae6bf65cd8c8"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__iterator.html#a82d4023ad9dc38dcde4cae6bf65cd8c8">slot_iterator</a> ()</td></tr>
+<tr class="separator:a82d4023ad9dc38dcde4cae6bf65cd8c8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a07933d72e788285673121e5ce019a260"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__iterator.html#a07933d72e788285673121e5ce019a260">slot_iterator</a> (const <a class="el" href="structsigc_1_1slot__iterator.html#a189fa620b9d90dc1a224d9ad91da5011">iterator_type</a> & i)</td></tr>
+<tr class="separator:a07933d72e788285673121e5ce019a260"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a880c8929759eca2fc7fb55cb0c813c55"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__iterator.html#a880c8929759eca2fc7fb55cb0c813c55">operator!=</a> (const <a class="el" href="structsigc_1_1slot__iterator.html">slot_iterator</a> & other) const</td></tr>
+<tr class="separator:a880c8929759eca2fc7fb55cb0c813c55"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa01dddd6f7b4e1a726a55cd1d430f398"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__iterator.html#aa3e69a557b73d817a1951af1b1767632">reference</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__iterator.html#aa01dddd6f7b4e1a726a55cd1d430f398">operator*</a> () const</td></tr>
+<tr class="separator:aa01dddd6f7b4e1a726a55cd1d430f398"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af5a3b852c1c6e8f69c41f64a17204758"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__iterator.html">slot_iterator</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__iterator.html#af5a3b852c1c6e8f69c41f64a17204758">operator++</a> ()</td></tr>
+<tr class="separator:af5a3b852c1c6e8f69c41f64a17204758"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7469f1ad5f1802d7a04f031ee4b3e54e"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__iterator.html">slot_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__iterator.html#a7469f1ad5f1802d7a04f031ee4b3e54e">operator++</a> (int)</td></tr>
+<tr class="separator:a7469f1ad5f1802d7a04f031ee4b3e54e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8aeef4e41dc0930beaa8d6a37b27775c"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__iterator.html">slot_iterator</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__iterator.html#a8aeef4e41dc0930beaa8d6a37b27775c">operator--</a> ()</td></tr>
+<tr class="separator:a8aeef4e41dc0930beaa8d6a37b27775c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:afd2ebfa71c2df96290f2bce0746d6fa5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__iterator.html">slot_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__iterator.html#afd2ebfa71c2df96290f2bce0746d6fa5">operator--</a> (int)</td></tr>
+<tr class="separator:afd2ebfa71c2df96290f2bce0746d6fa5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a0a77bd2eccf05cecbdf3b690c5301540"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__iterator.html#afb36f2add6064e0d7e7ae63ee2ddcde9">pointer</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__iterator.html#a0a77bd2eccf05cecbdf3b690c5301540">operator-></a> () const</td></tr>
+<tr class="separator:a0a77bd2eccf05cecbdf3b690c5301540"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2b4e16f15258f6cd98f8049afd0b88d"><td class="memItemLeft" align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__iterator.html#af2b4e16f15258f6cd98f8049afd0b88d">operator==</a> (const <a class="el" href="structsigc_1_1slot__iterator.html">slot_iterator</a> & other) const</td></tr>
+<tr class="separator:af2b4e16f15258f6cd98f8049afd0b88d"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Public Attributes</h2></td></tr>
+<tr class="memitem:a5e113a9e58ce7e16a11838a203b72649"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__iterator.html#a189fa620b9d90dc1a224d9ad91da5011">iterator_type</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__iterator.html#a5e113a9e58ce7e16a11838a203b72649">i_</a></td></tr>
+<tr class="separator:a5e113a9e58ce7e16a11838a203b72649"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<typename T_slot><br />
+struct sigc::slot_iterator< T_slot ></h3>
+
+<p>STL-style iterator for <a class="el" href="structsigc_1_1slot__list.html" title="STL-style list interface for sigc::signal#.">slot_list</a>. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="adb6307ee06c592d67ecef0607f319d5e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#adb6307ee06c592d67ecef0607f319d5e">◆ </a></span>difference_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef std::ptrdiff_t <a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator</a>< T_slot >::<a class="el" href="structsigc_1_1slot__iterator.html#adb6307ee06c592d67ecef0607f319d5e">difference_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a0c882521b418b9faaac879a1d337ace5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0c882521b418b9faaac879a1d337ace5">◆ </a></span>iterator_category</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a07517.html">std::bidirectional_iterator_tag</a> <a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator</a>< T_slot >::<a class="el" href="structsigc_1_1slot__iterator.html#a0c882521b418b9faaac879a1d337ace5">iterator_category</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a189fa620b9d90dc1a224d9ad91da5011"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a189fa620b9d90dc1a224d9ad91da5011">◆ </a></span>iterator_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__iterator.html">internal::signal_impl::iterator_type</a> <a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator</a>< T_slot >::<a class="el" href="structsigc_1_1slot__iterator.html#a189fa620b9d90dc1a224d9ad91da5011">iterator_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="afb36f2add6064e0d7e7ae63ee2ddcde9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#afb36f2add6064e0d7e7ae63ee2ddcde9">◆ </a></span>pointer</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_slot* <a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator</a>< T_slot >::<a class="el" href="structsigc_1_1slot__iterator.html#afb36f2add6064e0d7e7ae63ee2ddcde9">pointer</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aa3e69a557b73d817a1951af1b1767632"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa3e69a557b73d817a1951af1b1767632">◆ </a></span>reference</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_slot& <a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator</a>< T_slot >::<a class="el" href="structsigc_1_1slot__iterator.html#aa3e69a557b73d817a1951af1b1767632">reference</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a1dd8ea0a80b5bb0f936833a1c2e363ed"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1dd8ea0a80b5bb0f936833a1c2e363ed">◆ </a></span>size_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef std::size_t <a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator</a>< T_slot >::<a class="el" href="structsigc_1_1slot__iterator.html#a1dd8ea0a80b5bb0f936833a1c2e363ed">size_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="af7a0ed93fca0064021d77275305e04a9"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af7a0ed93fca0064021d77275305e04a9">◆ </a></span>slot_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_slot <a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator</a>< T_slot >::<a class="el" href="structsigc_1_1slot__iterator.html#af7a0ed93fca0064021d77275305e04a9">slot_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a94f7fcbd3224e1f7e88b84f9e326b0b3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a94f7fcbd3224e1f7e88b84f9e326b0b3">◆ </a></span>value_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_slot <a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator</a>< T_slot >::<a class="el" href="structsigc_1_1slot__iterator.html#a94f7fcbd3224e1f7e88b84f9e326b0b3">value_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a82d4023ad9dc38dcde4cae6bf65cd8c8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a82d4023ad9dc38dcde4cae6bf65cd8c8">◆ </a></span>slot_iterator() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator</a>< T_slot >::<a class="el" href="structsigc_1_1slot__iterator.html">slot_iterator</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a07933d72e788285673121e5ce019a260"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a07933d72e788285673121e5ce019a260">◆ </a></span>slot_iterator() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator</a>< T_slot >::<a class="el" href="structsigc_1_1slot__iterator.html">slot_iterator</a> </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="structsigc_1_1slot__iterator.html#a189fa620b9d90dc1a224d9ad91da5011">iterator_type</a> & </td>
+ <td class="paramname"><em>i</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a880c8929759eca2fc7fb55cb0c813c55"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a880c8929759eca2fc7fb55cb0c813c55">◆ </a></span>operator!=()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">bool <a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator</a>< T_slot >::<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01568.html#ga8ae9cabed8e455713324dacd39bedef1">operator!</a>= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="structsigc_1_1slot__iterator.html">slot_iterator</a>< T_slot > & </td>
+ <td class="paramname"><em>other</em></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aa01dddd6f7b4e1a726a55cd1d430f398"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa01dddd6f7b4e1a726a55cd1d430f398">◆ </a></span>operator*()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__iterator.html#aa3e69a557b73d817a1951af1b1767632">reference</a> <a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator</a>< T_slot >::operator* </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="af5a3b852c1c6e8f69c41f64a17204758"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af5a3b852c1c6e8f69c41f64a17204758">◆ </a></span>operator++() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__iterator.html">slot_iterator</a>& <a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator</a>< T_slot >::operator++ </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a7469f1ad5f1802d7a04f031ee4b3e54e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7469f1ad5f1802d7a04f031ee4b3e54e">◆ </a></span>operator++() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__iterator.html">slot_iterator</a> <a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator</a>< T_slot >::operator++ </td>
+ <td>(</td>
+ <td class="paramtype">int </td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a8aeef4e41dc0930beaa8d6a37b27775c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8aeef4e41dc0930beaa8d6a37b27775c">◆ </a></span>operator--() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__iterator.html">slot_iterator</a>& <a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator</a>< T_slot >::operator-- </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="afd2ebfa71c2df96290f2bce0746d6fa5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#afd2ebfa71c2df96290f2bce0746d6fa5">◆ </a></span>operator--() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__iterator.html">slot_iterator</a> <a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator</a>< T_slot >::operator-- </td>
+ <td>(</td>
+ <td class="paramtype">int </td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a0a77bd2eccf05cecbdf3b690c5301540"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a0a77bd2eccf05cecbdf3b690c5301540">◆ </a></span>operator->()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__iterator.html#afb36f2add6064e0d7e7ae63ee2ddcde9">pointer</a> <a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator</a>< T_slot >::operator-> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="af2b4e16f15258f6cd98f8049afd0b88d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af2b4e16f15258f6cd98f8049afd0b88d">◆ </a></span>operator==()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">bool <a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator</a>< T_slot >::operator== </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="structsigc_1_1slot__iterator.html">slot_iterator</a>< T_slot > & </td>
+ <td class="paramname"><em>other</em></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a5e113a9e58ce7e16a11838a203b72649"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5e113a9e58ce7e16a11838a203b72649">◆ </a></span>i_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <typename T_slot > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__iterator.html#a189fa620b9d90dc1a224d9ad91da5011">iterator_type</a> <a class="el" href="structsigc_1_1slot__iterator.html">sigc::slot_iterator</a>< T_slot >::i_</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1slot__list.html">slot_list</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::slot_list< T_slot > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#a2b1145f2e387c041913d01b5b197f12b">back</a>()</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#a09c5090912b6a7920269d3959e9698f4">back</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#ae179ec4300ddc793492bc574f6a92fec">begin</a>()</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#af5d0b9141e3206f2a7512e1ac4cc65fc">begin</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">const_iterator</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#a3ac6e61271e7e8623d1bd493c61f1214">const_reference</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">const_reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#affef6e4e62e4be8743c56aa8753f76d1">end</a>()</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#a1d5274891fad64cd2449914728b60bc1">end</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#a092ed557b1519062804a41e9b527e99d">erase</a>(iterator i)</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#a76e40607d0329865e549ac78105a5d7d">erase</a>(iterator first_, iterator last_)</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#abcd398b9cb6fe9506e548d121081163a">front</a>()</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#ac44ca78cb266a8c46758b276cea151a1">front</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#a34c421956609463692527793e49b87ae">insert</a>(iterator i, const slot_type & slot_)</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#ac4e8d8b623aed063b7873b5d2e1ce5f5">insert</a>(iterator i, slot_type && slot_)</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">iterator</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#a2c5b3ecf068ec93cdc34a4ae8d48313c">list_</a></td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#abb28f82ef0cbc78a86a4becd61b0c9ff">pop_back</a>()</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#a9244005ecc265b07b7f451e63662686e">pop_front</a>()</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#a5c7401657a6020c14616e62b20949de8">push_back</a>(const slot_type & c)</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#a48bf437419930c92756ee3b2162d08ad">push_back</a>(slot_type && c)</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#a5bb241c13cb363825f787ecd244ebf7d">push_front</a>(const slot_type & c)</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#a4179f2c80be5fb65544b19b3b1d4807e">push_front</a>(slot_type && c)</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#a898411734692d01a320b20a20d9e6978">rbegin</a>()</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#a1d4d33c9ac07a6012332d89100e8fbeb">rbegin</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#ab0f2255639f24ff02d45f97994bc0e11">reference</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#ae4759ca19577b31dca5116292e7de19c">rend</a>()</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#a805f74b49477673660b039576cbec20f">rend</a>() const</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">reverse_iterator</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#aa83ff2d263581f80f9d15d14fa31bc7a">slot_list</a>()</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#a5baac8e52fda5f6fc4fa31bed67077e3">slot_list</a>(internal::signal_impl * __list)</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">explicit</span></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1slot__list.html#af769819a62b19adb888eb231709e894f">slot_type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list< T_slot ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::slot_list< T_slot > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1slot__list.html">slot_list</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="#pro-attribs">Protected Attributes</a> |
+<a href="structsigc_1_1slot__list-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::slot_list< T_slot > Struct Template Reference<div class="ingroups"><a class="el" href="group__signal.html">Signals</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>STL-style list interface for <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a>#.
+ <a href="structsigc_1_1slot__list.html#details">More...</a></p>
+
+<p><code>#include <sigc++/signal.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a957838a7111e132824c10c2d5a897a0b"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__const__iterator.html">slot_const_iterator</a>< <a class="el" href="structsigc_1_1slot__list.html#af769819a62b19adb888eb231709e894f">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">const_iterator</a></td></tr>
+<tr class="separator:a957838a7111e132824c10c2d5a897a0b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a3ac6e61271e7e8623d1bd493c61f1214"><td class="memItemLeft" align="right" valign="top">typedef const <a class="el" href="structsigc_1_1slot__list.html#af769819a62b19adb888eb231709e894f">slot_type</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#a3ac6e61271e7e8623d1bd493c61f1214">const_reference</a></td></tr>
+<tr class="separator:a3ac6e61271e7e8623d1bd493c61f1214"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8293bfca54539958326f57375e4d8c14"><td class="memItemLeft" align="right" valign="top">typedef <a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a07465.html">std::reverse_iterator</a>< <a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">const_iterator</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">const_reverse_iterator</a></td></tr>
+<tr class="separator:a8293bfca54539958326f57375e4d8c14"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9774e07e467d9463e6e7cc7aa2f5c05f"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__iterator.html">slot_iterator</a>< <a class="el" href="structsigc_1_1slot__list.html#af769819a62b19adb888eb231709e894f">slot_type</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">iterator</a></td></tr>
+<tr class="separator:a9774e07e467d9463e6e7cc7aa2f5c05f"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ab0f2255639f24ff02d45f97994bc0e11"><td class="memItemLeft" align="right" valign="top">typedef <a class="el" href="structsigc_1_1slot__list.html#af769819a62b19adb888eb231709e894f">slot_type</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#ab0f2255639f24ff02d45f97994bc0e11">reference</a></td></tr>
+<tr class="separator:ab0f2255639f24ff02d45f97994bc0e11"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:addb44a7590825f917b3fcf0179fadadb"><td class="memItemLeft" align="right" valign="top">typedef <a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a07465.html">std::reverse_iterator</a>< <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">iterator</a> > </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">reverse_iterator</a></td></tr>
+<tr class="separator:addb44a7590825f917b3fcf0179fadadb"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af769819a62b19adb888eb231709e894f"><td class="memItemLeft" align="right" valign="top">typedef T_slot </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#af769819a62b19adb888eb231709e894f">slot_type</a></td></tr>
+<tr class="separator:af769819a62b19adb888eb231709e894f"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:aa83ff2d263581f80f9d15d14fa31bc7a"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#aa83ff2d263581f80f9d15d14fa31bc7a">slot_list</a> ()</td></tr>
+<tr class="separator:aa83ff2d263581f80f9d15d14fa31bc7a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5baac8e52fda5f6fc4fa31bed67077e3"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#a5baac8e52fda5f6fc4fa31bed67077e3">slot_list</a> (internal::signal_impl * __list)</td></tr>
+<tr class="separator:a5baac8e52fda5f6fc4fa31bed67077e3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2b1145f2e387c041913d01b5b197f12b"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__list.html#ab0f2255639f24ff02d45f97994bc0e11">reference</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#a2b1145f2e387c041913d01b5b197f12b">back</a> ()</td></tr>
+<tr class="separator:a2b1145f2e387c041913d01b5b197f12b"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a09c5090912b6a7920269d3959e9698f4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__list.html#a3ac6e61271e7e8623d1bd493c61f1214">const_reference</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#a09c5090912b6a7920269d3959e9698f4">back</a> () const</td></tr>
+<tr class="separator:a09c5090912b6a7920269d3959e9698f4"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae179ec4300ddc793492bc574f6a92fec"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#ae179ec4300ddc793492bc574f6a92fec">begin</a> ()</td></tr>
+<tr class="separator:ae179ec4300ddc793492bc574f6a92fec"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af5d0b9141e3206f2a7512e1ac4cc65fc"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#af5d0b9141e3206f2a7512e1ac4cc65fc">begin</a> () const</td></tr>
+<tr class="separator:af5d0b9141e3206f2a7512e1ac4cc65fc"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:affef6e4e62e4be8743c56aa8753f76d1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#affef6e4e62e4be8743c56aa8753f76d1">end</a> ()</td></tr>
+<tr class="separator:affef6e4e62e4be8743c56aa8753f76d1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1d5274891fad64cd2449914728b60bc1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">const_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#a1d5274891fad64cd2449914728b60bc1">end</a> () const</td></tr>
+<tr class="separator:a1d5274891fad64cd2449914728b60bc1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a76e40607d0329865e549ac78105a5d7d"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#a76e40607d0329865e549ac78105a5d7d">erase</a> (<a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">iterator</a> first_, <a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">iterator</a> last_)</td></tr>
+<tr class="separator:a76e40607d0329865e549ac78105a5d7d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a092ed557b1519062804a41e9b527e99d"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#a092ed557b1519062804a41e9b527e99d">erase</a> (<a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">iterator</a> i)</td></tr>
+<tr class="separator:a092ed557b1519062804a41e9b527e99d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abcd398b9cb6fe9506e548d121081163a"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__list.html#ab0f2255639f24ff02d45f97994bc0e11">reference</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#abcd398b9cb6fe9506e548d121081163a">front</a> ()</td></tr>
+<tr class="separator:abcd398b9cb6fe9506e548d121081163a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac44ca78cb266a8c46758b276cea151a1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__list.html#a3ac6e61271e7e8623d1bd493c61f1214">const_reference</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#ac44ca78cb266a8c46758b276cea151a1">front</a> () const</td></tr>
+<tr class="separator:ac44ca78cb266a8c46758b276cea151a1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a34c421956609463692527793e49b87ae"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#a34c421956609463692527793e49b87ae">insert</a> (<a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">iterator</a> i, const <a class="el" href="structsigc_1_1slot__list.html#af769819a62b19adb888eb231709e894f">slot_type</a> & slot_)</td></tr>
+<tr class="separator:a34c421956609463692527793e49b87ae"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac4e8d8b623aed063b7873b5d2e1ce5f5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#ac4e8d8b623aed063b7873b5d2e1ce5f5">insert</a> (<a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">iterator</a> i, <a class="el" href="structsigc_1_1slot__list.html#af769819a62b19adb888eb231709e894f">slot_type</a> && slot_)</td></tr>
+<tr class="separator:ac4e8d8b623aed063b7873b5d2e1ce5f5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:abb28f82ef0cbc78a86a4becd61b0c9ff"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#abb28f82ef0cbc78a86a4becd61b0c9ff">pop_back</a> ()</td></tr>
+<tr class="separator:abb28f82ef0cbc78a86a4becd61b0c9ff"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9244005ecc265b07b7f451e63662686e"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#a9244005ecc265b07b7f451e63662686e">pop_front</a> ()</td></tr>
+<tr class="separator:a9244005ecc265b07b7f451e63662686e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5c7401657a6020c14616e62b20949de8"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#a5c7401657a6020c14616e62b20949de8">push_back</a> (const <a class="el" href="structsigc_1_1slot__list.html#af769819a62b19adb888eb231709e894f">slot_type</a> & c)</td></tr>
+<tr class="separator:a5c7401657a6020c14616e62b20949de8"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a48bf437419930c92756ee3b2162d08ad"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#a48bf437419930c92756ee3b2162d08ad">push_back</a> (<a class="el" href="structsigc_1_1slot__list.html#af769819a62b19adb888eb231709e894f">slot_type</a> && c)</td></tr>
+<tr class="separator:a48bf437419930c92756ee3b2162d08ad"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a5bb241c13cb363825f787ecd244ebf7d"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#a5bb241c13cb363825f787ecd244ebf7d">push_front</a> (const <a class="el" href="structsigc_1_1slot__list.html#af769819a62b19adb888eb231709e894f">slot_type</a> & c)</td></tr>
+<tr class="separator:a5bb241c13cb363825f787ecd244ebf7d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4179f2c80be5fb65544b19b3b1d4807e"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#a4179f2c80be5fb65544b19b3b1d4807e">push_front</a> (<a class="el" href="structsigc_1_1slot__list.html#af769819a62b19adb888eb231709e894f">slot_type</a> && c)</td></tr>
+<tr class="separator:a4179f2c80be5fb65544b19b3b1d4807e"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a898411734692d01a320b20a20d9e6978"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#a898411734692d01a320b20a20d9e6978">rbegin</a> ()</td></tr>
+<tr class="separator:a898411734692d01a320b20a20d9e6978"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1d4d33c9ac07a6012332d89100e8fbeb"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#a1d4d33c9ac07a6012332d89100e8fbeb">rbegin</a> () const</td></tr>
+<tr class="separator:a1d4d33c9ac07a6012332d89100e8fbeb"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ae4759ca19577b31dca5116292e7de19c"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#ae4759ca19577b31dca5116292e7de19c">rend</a> ()</td></tr>
+<tr class="separator:ae4759ca19577b31dca5116292e7de19c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a805f74b49477673660b039576cbec20f"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">const_reverse_iterator</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#a805f74b49477673660b039576cbec20f">rend</a> () const</td></tr>
+<tr class="separator:a805f74b49477673660b039576cbec20f"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
+Protected Attributes</h2></td></tr>
+<tr class="memitem:a2c5b3ecf068ec93cdc34a4ae8d48313c"><td class="memItemLeft" align="right" valign="top">internal::signal_impl * </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1slot__list.html#a2c5b3ecf068ec93cdc34a4ae8d48313c">list_</a></td></tr>
+<tr class="separator:a2c5b3ecf068ec93cdc34a4ae8d48313c"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_slot><br />
+struct sigc::slot_list< T_slot ></h3>
+
+<p>STL-style list interface for <a class="el" href="classsigc_1_1signal.html" title="Convenience wrapper for the numbered sigc::signal# templates.">sigc::signal</a>#. </p>
+<p><a class="el" href="structsigc_1_1slot__list.html" title="STL-style list interface for sigc::signal#.">slot_list</a> 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. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a957838a7111e132824c10c2d5a897a0b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a957838a7111e132824c10c2d5a897a0b">◆ </a></span>const_iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__const__iterator.html">slot_const_iterator</a><<a class="el" href="structsigc_1_1slot__list.html#af769819a62b19adb888eb231709e894f">slot_type</a>> <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::<a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">const_iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a3ac6e61271e7e8623d1bd493c61f1214"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3ac6e61271e7e8623d1bd493c61f1214">◆ </a></span>const_reference</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef const <a class="el" href="structsigc_1_1slot__list.html#af769819a62b19adb888eb231709e894f">slot_type</a>& <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::<a class="el" href="structsigc_1_1slot__list.html#a3ac6e61271e7e8623d1bd493c61f1214">const_reference</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a8293bfca54539958326f57375e4d8c14"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a8293bfca54539958326f57375e4d8c14">◆ </a></span>const_reverse_iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a07465.html">std::reverse_iterator</a><<a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">const_iterator</a>> <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::<a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">const_reverse_iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a9774e07e467d9463e6e7cc7aa2f5c05f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9774e07e467d9463e6e7cc7aa2f5c05f">◆ </a></span>iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__iterator.html">slot_iterator</a><<a class="el" href="structsigc_1_1slot__list.html#af769819a62b19adb888eb231709e894f">slot_type</a>> <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::<a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ab0f2255639f24ff02d45f97994bc0e11"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab0f2255639f24ff02d45f97994bc0e11">◆ </a></span>reference</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="el" href="structsigc_1_1slot__list.html#af769819a62b19adb888eb231709e894f">slot_type</a>& <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::<a class="el" href="structsigc_1_1slot__list.html#ab0f2255639f24ff02d45f97994bc0e11">reference</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="addb44a7590825f917b3fcf0179fadadb"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#addb44a7590825f917b3fcf0179fadadb">◆ </a></span>reverse_iterator</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef <a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a07465.html">std::reverse_iterator</a><<a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">iterator</a>> <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::<a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">reverse_iterator</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="af769819a62b19adb888eb231709e894f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af769819a62b19adb888eb231709e894f">◆ </a></span>slot_type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_slot <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::<a class="el" href="structsigc_1_1slot__list.html#af769819a62b19adb888eb231709e894f">slot_type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="aa83ff2d263581f80f9d15d14fa31bc7a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aa83ff2d263581f80f9d15d14fa31bc7a">◆ </a></span>slot_list() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::<a class="el" href="structsigc_1_1slot__list.html">slot_list</a> </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a5baac8e52fda5f6fc4fa31bed67077e3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5baac8e52fda5f6fc4fa31bed67077e3">◆ </a></span>slot_list() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::<a class="el" href="structsigc_1_1slot__list.html">slot_list</a> </td>
+ <td>(</td>
+ <td class="paramtype">internal::signal_impl * </td>
+ <td class="paramname"><em>__list</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">explicit</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a2b1145f2e387c041913d01b5b197f12b"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2b1145f2e387c041913d01b5b197f12b">◆ </a></span>back() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__list.html#ab0f2255639f24ff02d45f97994bc0e11">reference</a> <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::back </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a09c5090912b6a7920269d3959e9698f4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a09c5090912b6a7920269d3959e9698f4">◆ </a></span>back() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__list.html#a3ac6e61271e7e8623d1bd493c61f1214">const_reference</a> <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::back </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ae179ec4300ddc793492bc574f6a92fec"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae179ec4300ddc793492bc574f6a92fec">◆ </a></span>begin() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">iterator</a> <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::begin </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="af5d0b9141e3206f2a7512e1ac4cc65fc"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af5d0b9141e3206f2a7512e1ac4cc65fc">◆ </a></span>begin() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">const_iterator</a> <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::begin </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="affef6e4e62e4be8743c56aa8753f76d1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#affef6e4e62e4be8743c56aa8753f76d1">◆ </a></span>end() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">iterator</a> <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::end </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a1d5274891fad64cd2449914728b60bc1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1d5274891fad64cd2449914728b60bc1">◆ </a></span>end() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b">const_iterator</a> <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::end </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a76e40607d0329865e549ac78105a5d7d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a76e40607d0329865e549ac78105a5d7d">◆ </a></span>erase() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">iterator</a> <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::erase </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">iterator</a> </td>
+ <td class="paramname"><em>first_</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">iterator</a> </td>
+ <td class="paramname"><em>last_</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a092ed557b1519062804a41e9b527e99d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a092ed557b1519062804a41e9b527e99d">◆ </a></span>erase() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">iterator</a> <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::erase </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">iterator</a> </td>
+ <td class="paramname"><em>i</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="abcd398b9cb6fe9506e548d121081163a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abcd398b9cb6fe9506e548d121081163a">◆ </a></span>front() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__list.html#ab0f2255639f24ff02d45f97994bc0e11">reference</a> <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::front </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ac44ca78cb266a8c46758b276cea151a1"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac44ca78cb266a8c46758b276cea151a1">◆ </a></span>front() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__list.html#a3ac6e61271e7e8623d1bd493c61f1214">const_reference</a> <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::front </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a34c421956609463692527793e49b87ae"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a34c421956609463692527793e49b87ae">◆ </a></span>insert() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">iterator</a> <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::insert </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">iterator</a> </td>
+ <td class="paramname"><em>i</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const <a class="el" href="structsigc_1_1slot__list.html#af769819a62b19adb888eb231709e894f">slot_type</a> & </td>
+ <td class="paramname"><em>slot_</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ac4e8d8b623aed063b7873b5d2e1ce5f5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac4e8d8b623aed063b7873b5d2e1ce5f5">◆ </a></span>insert() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">iterator</a> <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::insert </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f">iterator</a> </td>
+ <td class="paramname"><em>i</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="structsigc_1_1slot__list.html#af769819a62b19adb888eb231709e894f">slot_type</a> && </td>
+ <td class="paramname"><em>slot_</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="abb28f82ef0cbc78a86a4becd61b0c9ff"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abb28f82ef0cbc78a86a4becd61b0c9ff">◆ </a></span>pop_back()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">void <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::pop_back </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a9244005ecc265b07b7f451e63662686e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9244005ecc265b07b7f451e63662686e">◆ </a></span>pop_front()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">void <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::pop_front </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a5c7401657a6020c14616e62b20949de8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5c7401657a6020c14616e62b20949de8">◆ </a></span>push_back() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">void <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::push_back </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="structsigc_1_1slot__list.html#af769819a62b19adb888eb231709e894f">slot_type</a> & </td>
+ <td class="paramname"><em>c</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a48bf437419930c92756ee3b2162d08ad"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a48bf437419930c92756ee3b2162d08ad">◆ </a></span>push_back() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">void <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::push_back </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="structsigc_1_1slot__list.html#af769819a62b19adb888eb231709e894f">slot_type</a> && </td>
+ <td class="paramname"><em>c</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a5bb241c13cb363825f787ecd244ebf7d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a5bb241c13cb363825f787ecd244ebf7d">◆ </a></span>push_front() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">void <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::push_front </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="structsigc_1_1slot__list.html#af769819a62b19adb888eb231709e894f">slot_type</a> & </td>
+ <td class="paramname"><em>c</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a4179f2c80be5fb65544b19b3b1d4807e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a4179f2c80be5fb65544b19b3b1d4807e">◆ </a></span>push_front() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">void <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::push_front </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="structsigc_1_1slot__list.html#af769819a62b19adb888eb231709e894f">slot_type</a> && </td>
+ <td class="paramname"><em>c</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a898411734692d01a320b20a20d9e6978"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a898411734692d01a320b20a20d9e6978">◆ </a></span>rbegin() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">reverse_iterator</a> <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::rbegin </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a1d4d33c9ac07a6012332d89100e8fbeb"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1d4d33c9ac07a6012332d89100e8fbeb">◆ </a></span>rbegin() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">const_reverse_iterator</a> <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::rbegin </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ae4759ca19577b31dca5116292e7de19c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae4759ca19577b31dca5116292e7de19c">◆ </a></span>rend() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb">reverse_iterator</a> <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::rend </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a805f74b49477673660b039576cbec20f"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a805f74b49477673660b039576cbec20f">◆ </a></span>rend() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14">const_reverse_iterator</a> <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::rend </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Data Documentation</h2>
+<a id="a2c5b3ecf068ec93cdc34a4ae8d48313c"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2c5b3ecf068ec93cdc34a4ae8d48313c">◆ </a></span>list_</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_slot > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">internal::signal_impl* <a class="el" href="structsigc_1_1slot__list.html">sigc::slot_list</a>< T_slot >::list_</td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">protected</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1trackable.html">trackable</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::trackable Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a>(void * data, func_destroy_notify func) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a>(const trackable & src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a>(void * data) const</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a>() noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a>(const trackable & src) noexcept</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a>(trackable && src)</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a>()</td><td class="entry"><a class="el" href="structsigc_1_1trackable.html">sigc::trackable</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::trackable Struct Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1trackable.html">trackable</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="#pub-methods">Public Member Functions</a> |
+<a href="structsigc_1_1trackable-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::trackable Struct Reference<div class="ingroups"><a class="el" href="group__signal.html">Signals</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Base class for objects with auto-disconnection.
+ <a href="structsigc_1_1trackable.html#details">More...</a></p>
+
+<p><code>#include <sigc++/trackable.h></code></p>
+<div class="dynheader">
+Inheritance diagram for sigc::trackable:</div>
+<div class="dyncontent">
+<div class="center"><img src="structsigc_1_1trackable__inherit__graph.png" border="0" usemap="#asigc_1_1trackable_inherit__map" alt="Inheritance graph"/></div>
+<map name="asigc_1_1trackable_inherit__map" id="asigc_1_1trackable_inherit__map">
+<area shape="rect" title="Base class for objects with auto-disconnection." alt="" coords="5,1193,121,1219"/>
+<area shape="rect" title=" " alt="" coords="169,666,336,693"/>
+<area shape="rect" href="structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="186,1218,319,1245"/>
+<area shape="rect" title=" " alt="" coords="419,135,591,176"/>
+<area shape="rect" href="classsigc_1_1signal0.html" title=" " alt="" coords="417,200,593,241"/>
+<area shape="rect" href="classsigc_1_1signal0.html" title=" " alt="" coords="417,265,593,307"/>
+<area shape="rect" href="classsigc_1_1signal1.html" title=" " alt="" coords="417,371,593,412"/>
+<area shape="rect" href="classsigc_1_1signal1.html" title=" " alt="" coords="410,616,599,657"/>
+<area shape="rect" href="classsigc_1_1signal2.html" title=" " alt="" coords="384,759,625,800"/>
+<area shape="rect" href="classsigc_1_1signal2.html" title=" " alt="" coords="417,868,593,909"/>
+<area shape="rect" href="classsigc_1_1signal3.html" title=" " alt="" coords="415,1065,594,1121"/>
+<area shape="rect" href="classsigc_1_1signal3.html" title=" " alt="" coords="415,1163,594,1219"/>
+<area shape="rect" href="classsigc_1_1signal4.html" title=" " alt="" coords="415,1243,594,1299"/>
+<area shape="rect" href="classsigc_1_1signal4.html" title=" " alt="" coords="410,1323,599,1379"/>
+<area shape="rect" href="classsigc_1_1signal5.html" title=" " alt="" coords="384,1403,625,1459"/>
+<area shape="rect" href="classsigc_1_1signal5.html" title=" " alt="" coords="415,1483,594,1539"/>
+<area shape="rect" href="classsigc_1_1signal6.html" title=" " alt="" coords="415,1564,594,1635"/>
+<area shape="rect" href="classsigc_1_1signal6.html" title=" " alt="" coords="398,1659,611,1715"/>
+<area shape="rect" href="classsigc_1_1signal7.html" title=" " alt="" coords="417,1739,593,1795"/>
+<area shape="rect" href="classsigc_1_1signal7.html" title=" " alt="" coords="410,1820,599,1891"/>
+<area shape="rect" href="classsigc_1_1signal7.html" title=" " alt="" coords="415,1915,594,1985"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal0 template." alt="" coords="680,5,941,47"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal0 template." alt="" coords="724,71,897,141"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="718,166,903,193"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal0 template." alt="" coords="727,217,895,273"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="729,297,893,339"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal1 template." alt="" coords="727,363,895,419"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal1 template." alt="" coords="721,443,900,499"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal1 template." alt="" coords="712,524,909,595"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal2 template." alt="" coords="695,619,926,675"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal2 template." alt="" coords="695,700,927,771"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="729,795,893,836"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal2 template." alt="" coords="727,861,895,917"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal3 template." alt="" coords="685,941,936,997"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html" title="Convenience wrapper for the numbered sigc::signal3 template." alt="" coords="700,1021,921,1092"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="715,1116,906,1157"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal3 template." alt="" coords="721,1182,900,1238"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="721,1262,900,1318"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal4 template." alt="" coords="721,1342,900,1398"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal4 template." alt="" coords="716,1423,905,1493"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html" title="Convenience wrapper for the numbered sigc::signal4 template." alt="" coords="691,1517,931,1588"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal5 template." alt="" coords="695,1612,926,1683"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html" title="Convenience wrapper for the numbered sigc::signal5 template." alt="" coords="683,1707,938,1777"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="721,1802,900,1858"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal5 template." alt="" coords="718,1882,903,1938"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html" title="Convenience wrapper for the numbered sigc::signal6 template." alt="" coords="685,1963,936,2033"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html" title="Convenience wrapper for the numbered sigc::signal6 template." alt="" coords="673,2057,948,2128"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="715,2153,906,2209"/>
+<area shape="rect" href="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal6 template." alt="" coords="704,2233,917,2289"/>
+</map>
+<center><span class="legend">[<a href="graph_legend.html">legend</a>]</span></center></div>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a3338954d7565534bd945290b798e13ed"><td class="memItemLeft" align="right" valign="top">typedef internal::func_destroy_notify </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a></td></tr>
+<tr class="separator:a3338954d7565534bd945290b798e13ed"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a7e1348841e762fb41b41c6f2ce9fa073"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073">trackable</a> () noexcept</td></tr>
+<tr class="separator:a7e1348841e762fb41b41c6f2ce9fa073"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac8431d9452c9698a012597e6560c72fa"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa">trackable</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src) noexcept</td></tr>
+<tr class="separator:ac8431d9452c9698a012597e6560c72fa"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aba42ed8afb6598106cf68c18a7387f18"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18">trackable</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:aba42ed8afb6598106cf68c18a7387f18"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a75587da09e30031db7a2519843f1f4fb"><td class="memItemLeft" align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb">~trackable</a> ()</td></tr>
+<tr class="separator:a75587da09e30031db7a2519843f1f4fb"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aed95b40846f61b4f202348c71d5913ea"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">add_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>, <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> func) const</td></tr>
+<tr class="memdesc:aed95b40846f61b4f202348c71d5913ea"><td class="mdescLeft"> </td><td class="mdescRight">Add a callback that is executed (notified) when the trackable object is detroyed. <a href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea">More...</a><br /></td></tr>
+<tr class="separator:aed95b40846f61b4f202348c71d5913ea"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af2e23cfe7adc1ca844a3350bbac557cb"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">notify_callbacks</a> ()</td></tr>
+<tr class="memdesc:af2e23cfe7adc1ca844a3350bbac557cb"><td class="mdescLeft"> </td><td class="mdescRight">Execute and remove all previously installed callbacks. <a href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb">More...</a><br /></td></tr>
+<tr class="separator:af2e23cfe7adc1ca844a3350bbac557cb"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7494fbad23a65932ff1457d00d4edaf5"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5">operator=</a> (const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & src)</td></tr>
+<tr class="separator:a7494fbad23a65932ff1457d00d4edaf5"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ac3d61cdb452dc46fcdc8a8d42d9c079d"><td class="memItemLeft" align="right" valign="top"><a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d">operator=</a> (<a class="el" href="structsigc_1_1trackable.html">trackable</a> && src)</td></tr>
+<tr class="separator:ac3d61cdb452dc46fcdc8a8d42d9c079d"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ad1c1845ff5b356f13b32180077f83cff"><td class="memItemLeft" align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">remove_destroy_notify_callback</a> (void *<a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01635.html#a4a0b2b9455f1e2025d77ba49b3863e33">data</a>) const</td></tr>
+<tr class="memdesc:ad1c1845ff5b356f13b32180077f83cff"><td class="mdescLeft"> </td><td class="mdescRight">Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. <a href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff">More...</a><br /></td></tr>
+<tr class="separator:ad1c1845ff5b356f13b32180077f83cff"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><p>Base class for objects with auto-disconnection. </p>
+<p>trackable must be inherited when objects shall automatically invalidate slots referring to them on destruction. A slot built from a member function of a trackable derived type installs a callback that is invoked when the trackable object is destroyed or overwritten.</p>
+<p><a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a> and <a class="el" href="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff" title="Remove a callback previously installed with add_destroy_notify_callback().">remove_destroy_notify_callback()</a> can be used to manually install and remove callbacks when notification of the object dying is needed.</p>
+<p><a class="el" href="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb" title="Execute and remove all previously installed callbacks.">notify_callbacks()</a> invokes and removes all previously installed callbacks and can therefore be used to disconnect from all signals.</p>
+<p>Note that there is no virtual destructor. Don't use <code>trackable*</code> as pointer type for managing your data or the destructors of your derived types won't be called when deleting your objects. </p>
+</div><h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a3338954d7565534bd945290b798e13ed"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a3338954d7565534bd945290b798e13ed">◆ </a></span>func_destroy_notify</h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef internal::func_destroy_notify <a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">sigc::trackable::func_destroy_notify</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Constructor & Destructor Documentation</h2>
+<a id="a7e1348841e762fb41b41c6f2ce9fa073"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7e1348841e762fb41b41c6f2ce9fa073">◆ </a></span>trackable() <span class="overload">[1/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">sigc::trackable::trackable </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">noexcept</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ac8431d9452c9698a012597e6560c72fa"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac8431d9452c9698a012597e6560c72fa">◆ </a></span>trackable() <span class="overload">[2/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">sigc::trackable::trackable </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">noexcept</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="aba42ed8afb6598106cf68c18a7387f18"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aba42ed8afb6598106cf68c18a7387f18">◆ </a></span>trackable() <span class="overload">[3/3]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname">sigc::trackable::trackable </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="structsigc_1_1trackable.html">trackable</a> && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a75587da09e30031db7a2519843f1f4fb"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a75587da09e30031db7a2519843f1f4fb">◆ </a></span>~trackable()</h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname">sigc::trackable::~trackable </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="aed95b40846f61b4f202348c71d5913ea"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aed95b40846f61b4f202348c71d5913ea">◆ </a></span>add_destroy_notify_callback()</h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname">void sigc::trackable::add_destroy_notify_callback </td>
+ <td>(</td>
+ <td class="paramtype">void * </td>
+ <td class="paramname"><em>data</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype"><a class="el" href="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed">func_destroy_notify</a> </td>
+ <td class="paramname"><em>func</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td> const</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+<p>Add a callback that is executed (notified) when the trackable object is detroyed. </p>
+<dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">data</td><td>Passed into func upon notification. </td></tr>
+ <tr><td class="paramname">func</td><td>Callback executed upon destruction of the object. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+<a id="af2e23cfe7adc1ca844a3350bbac557cb"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af2e23cfe7adc1ca844a3350bbac557cb">◆ </a></span>notify_callbacks()</h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname">void sigc::trackable::notify_callbacks </td>
+ <td>(</td>
+ <td class="paramname"></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+<p>Execute and remove all previously installed callbacks. </p>
+
+</div>
+</div>
+<a id="a7494fbad23a65932ff1457d00d4edaf5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7494fbad23a65932ff1457d00d4edaf5">◆ </a></span>operator=() <span class="overload">[1/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1trackable.html">trackable</a>& sigc::trackable::operator= </td>
+ <td>(</td>
+ <td class="paramtype">const <a class="el" href="structsigc_1_1trackable.html">trackable</a> & </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ac3d61cdb452dc46fcdc8a8d42d9c079d"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ac3d61cdb452dc46fcdc8a8d42d9c079d">◆ </a></span>operator=() <span class="overload">[2/2]</span></h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname"><a class="el" href="structsigc_1_1trackable.html">trackable</a>& sigc::trackable::operator= </td>
+ <td>(</td>
+ <td class="paramtype"><a class="el" href="structsigc_1_1trackable.html">trackable</a> && </td>
+ <td class="paramname"><em>src</em></td><td>)</td>
+ <td></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="ad1c1845ff5b356f13b32180077f83cff"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ad1c1845ff5b356f13b32180077f83cff">◆ </a></span>remove_destroy_notify_callback()</h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname">void sigc::trackable::remove_destroy_notify_callback </td>
+ <td>(</td>
+ <td class="paramtype">void * </td>
+ <td class="paramname"><em>data</em></td><td>)</td>
+ <td> const</td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+<p>Remove a callback previously installed with <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. </p>
+<p>The callback is not executed. </p><dl class="params"><dt>Parameters</dt><dd>
+ <table class="params">
+ <tr><td class="paramname">data</td><td>Parameter passed into previous call to <a class="el" href="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" title="Add a callback that is executed (notified) when the trackable object is detroyed.">add_destroy_notify_callback()</a>. </td></tr>
+ </table>
+ </dd>
+</dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<map id="sigc::trackable" name="sigc::trackable">
+<area shape="rect" id="node1" title="Base class for objects with auto-disconnection." alt="" coords="5,1193,121,1219"/>
+<area shape="rect" id="node2" title=" " alt="" coords="169,666,336,693"/>
+<area shape="rect" id="node4" href="$structsigc_1_1signal__base.html" title="Base class for the sigc::signal# templates." alt="" coords="186,1218,319,1245"/>
+<area shape="rect" id="node3" title=" " alt="" coords="419,135,591,176"/>
+<area shape="rect" id="node5" href="$classsigc_1_1signal0.html" title=" " alt="" coords="417,200,593,241"/>
+<area shape="rect" id="node8" href="$classsigc_1_1signal0.html" title=" " alt="" coords="417,265,593,307"/>
+<area shape="rect" id="node11" href="$classsigc_1_1signal1.html" title=" " alt="" coords="417,371,593,412"/>
+<area shape="rect" id="node14" href="$classsigc_1_1signal1.html" title=" " alt="" coords="410,616,599,657"/>
+<area shape="rect" id="node17" href="$classsigc_1_1signal2.html" title=" " alt="" coords="384,759,625,800"/>
+<area shape="rect" id="node20" href="$classsigc_1_1signal2.html" title=" " alt="" coords="417,868,593,909"/>
+<area shape="rect" id="node23" href="$classsigc_1_1signal3.html" title=" " alt="" coords="415,1065,594,1121"/>
+<area shape="rect" id="node26" href="$classsigc_1_1signal3.html" title=" " alt="" coords="415,1163,594,1219"/>
+<area shape="rect" id="node29" href="$classsigc_1_1signal4.html" title=" " alt="" coords="415,1243,594,1299"/>
+<area shape="rect" id="node32" href="$classsigc_1_1signal4.html" title=" " alt="" coords="410,1323,599,1379"/>
+<area shape="rect" id="node35" href="$classsigc_1_1signal5.html" title=" " alt="" coords="384,1403,625,1459"/>
+<area shape="rect" id="node38" href="$classsigc_1_1signal5.html" title=" " alt="" coords="415,1483,594,1539"/>
+<area shape="rect" id="node41" href="$classsigc_1_1signal6.html" title=" " alt="" coords="415,1564,594,1635"/>
+<area shape="rect" id="node44" href="$classsigc_1_1signal6.html" title=" " alt="" coords="398,1659,611,1715"/>
+<area shape="rect" id="node47" href="$classsigc_1_1signal7.html" title=" " alt="" coords="417,1739,593,1795"/>
+<area shape="rect" id="node48" href="$classsigc_1_1signal7.html" title=" " alt="" coords="410,1820,599,1891"/>
+<area shape="rect" id="node49" href="$classsigc_1_1signal7.html" title=" " alt="" coords="415,1915,594,1985"/>
+<area shape="rect" id="node6" href="$classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal0 template." alt="" coords="680,5,941,47"/>
+<area shape="rect" id="node7" href="$classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal0 template." alt="" coords="724,71,897,141"/>
+<area shape="rect" id="node9" href="$classsigc_1_1signal_3_01T__return_07_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="718,166,903,193"/>
+<area shape="rect" id="node10" href="$classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal0 template." alt="" coords="727,217,895,273"/>
+<area shape="rect" id="node12" href="$classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="729,297,893,339"/>
+<area shape="rect" id="node13" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal1 template." alt="" coords="727,363,895,419"/>
+<area shape="rect" id="node15" href="$classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal1 template." alt="" coords="721,443,900,499"/>
+<area shape="rect" id="node16" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal1 template." alt="" coords="712,524,909,595"/>
+<area shape="rect" id="node18" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal2 template." alt="" coords="695,619,926,675"/>
+<area shape="rect" id="node19" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal2 template." alt="" coords="695,700,927,771"/>
+<area shape="rect" id="node21" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="729,795,893,836"/>
+<area shape="rect" id="node22" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal2 template." alt="" coords="727,861,895,917"/>
+<area shape="rect" id="node24" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal3 template." alt="" coords="685,941,936,997"/>
+<area shape="rect" id="node25" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html" title="Convenience wrapper for the numbered sigc::signal3 template." alt="" coords="700,1021,921,1092"/>
+<area shape="rect" id="node27" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="715,1116,906,1157"/>
+<area shape="rect" id="node28" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal3 template." alt="" coords="721,1182,900,1238"/>
+<area shape="rect" id="node30" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="721,1262,900,1318"/>
+<area shape="rect" id="node31" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal4 template." alt="" coords="721,1342,900,1398"/>
+<area shape="rect" id="node33" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal4 template." alt="" coords="716,1423,905,1493"/>
+<area shape="rect" id="node34" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html" title="Convenience wrapper for the numbered sigc::signal4 template." alt="" coords="691,1517,931,1588"/>
+<area shape="rect" id="node36" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html" title="Convenience wrapper for the numbered sigc::signal5 template." alt="" coords="695,1612,926,1683"/>
+<area shape="rect" id="node37" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html" title="Convenience wrapper for the numbered sigc::signal5 template." alt="" coords="683,1707,938,1777"/>
+<area shape="rect" id="node39" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="721,1802,900,1858"/>
+<area shape="rect" id="node40" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal5 template." alt="" coords="718,1882,903,1938"/>
+<area shape="rect" id="node42" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html" title="Convenience wrapper for the numbered sigc::signal6 template." alt="" coords="685,1963,936,2033"/>
+<area shape="rect" id="node43" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html" title="Convenience wrapper for the numbered sigc::signal6 template." alt="" coords="673,2057,948,2128"/>
+<area shape="rect" id="node45" href="$classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html" title="This specialization allow use of the sigc::signal<R(Args...)> syntax,." alt="" coords="715,2153,906,2209"/>
+<area shape="rect" id="node46" href="$classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html" title="Convenience wrapper for the numbered sigc::signal6 template." alt="" coords="704,2233,917,2289"/>
+</map>
--- /dev/null
+3d6181a7795479c03313d68c44051ef4
\ No newline at end of file
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1type__trait.html">type_trait</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::type_trait< T_type > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1type__trait.html">sigc::type_trait< T_type ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1type__trait.html#aebfa426334f8de7b93031de35d2495e3">pass</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1type__trait.html">sigc::type_trait< T_type ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1type__trait.html#a191a797ea6e2d851287b8a87b6305157">take</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1type__trait.html">sigc::type_trait< T_type ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::type_trait< T_type > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1type__trait.html">type_trait</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="structsigc_1_1type__trait-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::type_trait< T_type > Struct Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><code>#include <sigc++/type_traits.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:aebfa426334f8de7b93031de35d2495e3"><td class="memItemLeft" align="right" valign="top">typedef T_type & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1type__trait.html#aebfa426334f8de7b93031de35d2495e3">pass</a></td></tr>
+<tr class="separator:aebfa426334f8de7b93031de35d2495e3"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a191a797ea6e2d851287b8a87b6305157"><td class="memItemLeft" align="right" valign="top">typedef const T_type & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1type__trait.html#a191a797ea6e2d851287b8a87b6305157">take</a></td></tr>
+<tr class="separator:a191a797ea6e2d851287b8a87b6305157"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="aebfa426334f8de7b93031de35d2495e3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#aebfa426334f8de7b93031de35d2495e3">◆ </a></span>pass</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_type& <a class="el" href="structsigc_1_1type__trait.html">sigc::type_trait</a>< T_type >::<a class="el" href="structsigc_1_1type__trait.html#aebfa426334f8de7b93031de35d2495e3">pass</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a191a797ea6e2d851287b8a87b6305157"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a191a797ea6e2d851287b8a87b6305157">◆ </a></span>take</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef const T_type& <a class="el" href="structsigc_1_1type__trait.html">sigc::type_trait</a>< T_type >::<a class="el" href="structsigc_1_1type__trait.html#a191a797ea6e2d851287b8a87b6305157">take</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1type__trait_3_01T__type_01_6_01_4.html">type_trait< T_type & ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::type_trait< T_type & > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1type__trait_3_01T__type_01_6_01_4.html">sigc::type_trait< T_type & ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1type__trait_3_01T__type_01_6_01_4.html#a1b24e79fed94df3fc0e7574e0ae1c991">pass</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1type__trait_3_01T__type_01_6_01_4.html">sigc::type_trait< T_type & ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1type__trait_3_01T__type_01_6_01_4.html#a604c7ad05de42e3f9d28ab45c8d865b5">take</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1type__trait_3_01T__type_01_6_01_4.html">sigc::type_trait< T_type & ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::type_trait< T_type & > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1type__trait_3_01T__type_01_6_01_4.html">type_trait< T_type & ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="structsigc_1_1type__trait_3_01T__type_01_6_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::type_trait< T_type & > Struct Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><code>#include <sigc++/type_traits.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a1b24e79fed94df3fc0e7574e0ae1c991"><td class="memItemLeft" align="right" valign="top">typedef T_type & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1type__trait_3_01T__type_01_6_01_4.html#a1b24e79fed94df3fc0e7574e0ae1c991">pass</a></td></tr>
+<tr class="separator:a1b24e79fed94df3fc0e7574e0ae1c991"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a604c7ad05de42e3f9d28ab45c8d865b5"><td class="memItemLeft" align="right" valign="top">typedef T_type & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1type__trait_3_01T__type_01_6_01_4.html#a604c7ad05de42e3f9d28ab45c8d865b5">take</a></td></tr>
+<tr class="separator:a604c7ad05de42e3f9d28ab45c8d865b5"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a1b24e79fed94df3fc0e7574e0ae1c991"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a1b24e79fed94df3fc0e7574e0ae1c991">◆ </a></span>pass</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_type& <a class="el" href="structsigc_1_1type__trait.html">sigc::type_trait</a>< T_type & >::<a class="el" href="structsigc_1_1type__trait_3_01T__type_01_6_01_4.html#a1b24e79fed94df3fc0e7574e0ae1c991">pass</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a604c7ad05de42e3f9d28ab45c8d865b5"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a604c7ad05de42e3f9d28ab45c8d865b5">◆ </a></span>take</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_type& <a class="el" href="structsigc_1_1type__trait.html">sigc::type_trait</a>< T_type & >::<a class="el" href="structsigc_1_1type__trait_3_01T__type_01_6_01_4.html#a604c7ad05de42e3f9d28ab45c8d865b5">take</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html">type_trait< T_type[N]></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::type_trait< T_type[N]> Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html">sigc::type_trait< T_type[N]></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html#abfd06dd56be6fda2436e9e15acb1fc72">pass</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html">sigc::type_trait< T_type[N]></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html#a9cb9e2faaa68a89ef1a74b8b7c98d81e">take</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html">sigc::type_trait< T_type[N]></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::type_trait< T_type[N]> Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html">type_trait< T_type[N]></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="structsigc_1_1type__trait_3_01T__type_0fN_0e_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::type_trait< T_type[N]> Struct Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><code>#include <sigc++/type_traits.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:abfd06dd56be6fda2436e9e15acb1fc72"><td class="memItemLeft" align="right" valign="top">typedef T_type *& </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html#abfd06dd56be6fda2436e9e15acb1fc72">pass</a></td></tr>
+<tr class="separator:abfd06dd56be6fda2436e9e15acb1fc72"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a9cb9e2faaa68a89ef1a74b8b7c98d81e"><td class="memItemLeft" align="right" valign="top">typedef const T_type *& </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html#a9cb9e2faaa68a89ef1a74b8b7c98d81e">take</a></td></tr>
+<tr class="separator:a9cb9e2faaa68a89ef1a74b8b7c98d81e"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="abfd06dd56be6fda2436e9e15acb1fc72"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#abfd06dd56be6fda2436e9e15acb1fc72">◆ </a></span>pass</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type , int N> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_type*& <a class="el" href="structsigc_1_1type__trait.html">sigc::type_trait</a>< T_type[N]>::<a class="el" href="structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html#abfd06dd56be6fda2436e9e15acb1fc72">pass</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a9cb9e2faaa68a89ef1a74b8b7c98d81e"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9cb9e2faaa68a89ef1a74b8b7c98d81e">◆ </a></span>take</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type , int N> </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef const T_type*& <a class="el" href="structsigc_1_1type__trait.html">sigc::type_trait</a>< T_type[N]>::<a class="el" href="structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html#a9cb9e2faaa68a89ef1a74b8b7c98d81e">take</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html">type_trait< const T_type & ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::type_trait< const T_type & > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html">sigc::type_trait< const T_type & ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html#a7b9cd2a3e6e7cf986e4e25e05c665c73">pass</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html">sigc::type_trait< const T_type & ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html#a2c3a2a62adee114867045a7f77096435">take</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html">sigc::type_trait< const T_type & ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::type_trait< const T_type & > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html">type_trait< const T_type & ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::type_trait< const T_type & > Struct Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><code>#include <sigc++/type_traits.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a7b9cd2a3e6e7cf986e4e25e05c665c73"><td class="memItemLeft" align="right" valign="top">typedef const T_type & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html#a7b9cd2a3e6e7cf986e4e25e05c665c73">pass</a></td></tr>
+<tr class="separator:a7b9cd2a3e6e7cf986e4e25e05c665c73"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a2c3a2a62adee114867045a7f77096435"><td class="memItemLeft" align="right" valign="top">typedef const T_type & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html#a2c3a2a62adee114867045a7f77096435">take</a></td></tr>
+<tr class="separator:a2c3a2a62adee114867045a7f77096435"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a7b9cd2a3e6e7cf986e4e25e05c665c73"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a7b9cd2a3e6e7cf986e4e25e05c665c73">◆ </a></span>pass</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef const T_type& <a class="el" href="structsigc_1_1type__trait.html">sigc::type_trait</a>< const T_type & >::<a class="el" href="structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html#a7b9cd2a3e6e7cf986e4e25e05c665c73">pass</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a2c3a2a62adee114867045a7f77096435"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2c3a2a62adee114867045a7f77096435">◆ </a></span>take</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef const T_type& <a class="el" href="structsigc_1_1type__trait.html">sigc::type_trait</a>< const T_type & >::<a class="el" href="structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html#a2c3a2a62adee114867045a7f77096435">take</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1type__trait_3_01void_01_4.html">type_trait< void ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::type_trait< void > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1type__trait_3_01void_01_4.html">sigc::type_trait< void ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1type__trait_3_01void_01_4.html#ab5d97b4ec126f3afeaf67e9a6b05b0be">pass</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1type__trait_3_01void_01_4.html">sigc::type_trait< void ></a></td><td class="entry"></td></tr>
+ <tr><td class="entry"><a class="el" href="structsigc_1_1type__trait_3_01void_01_4.html#a40d187392469ee48d24838ef38531b90">take</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1type__trait_3_01void_01_4.html">sigc::type_trait< void ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::type_trait< void > Struct Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1type__trait_3_01void_01_4.html">type_trait< void ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="structsigc_1_1type__trait_3_01void_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::type_trait< void > Struct Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><code>#include <sigc++/type_traits.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:ab5d97b4ec126f3afeaf67e9a6b05b0be"><td class="memItemLeft" align="right" valign="top">typedef void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1type__trait_3_01void_01_4.html#ab5d97b4ec126f3afeaf67e9a6b05b0be">pass</a></td></tr>
+<tr class="separator:ab5d97b4ec126f3afeaf67e9a6b05b0be"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a40d187392469ee48d24838ef38531b90"><td class="memItemLeft" align="right" valign="top">typedef void </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1type__trait_3_01void_01_4.html#a40d187392469ee48d24838ef38531b90">take</a></td></tr>
+<tr class="separator:a40d187392469ee48d24838ef38531b90"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="ab5d97b4ec126f3afeaf67e9a6b05b0be"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ab5d97b4ec126f3afeaf67e9a6b05b0be">◆ </a></span>pass</h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef void <a class="el" href="structsigc_1_1type__trait.html">sigc::type_trait</a>< void >::<a class="el" href="structsigc_1_1type__trait_3_01void_01_4.html#ab5d97b4ec126f3afeaf67e9a6b05b0be">pass</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<a id="a40d187392469ee48d24838ef38531b90"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a40d187392469ee48d24838ef38531b90">◆ </a></span>take</h2>
+
+<div class="memitem">
+<div class="memproto">
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef void <a class="el" href="structsigc_1_1type__trait.html">sigc::type_trait</a>< void >::<a class="el" href="structsigc_1_1type__trait_3_01void_01_4.html#a40d187392469ee48d24838ef38531b90">take</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1unwrap__reference.html">unwrap_reference</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::unwrap_reference< T_type > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1unwrap__reference.html">sigc::unwrap_reference< T_type ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1unwrap__reference.html#af35cad963fc073623282a2fb9c81f02a">type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1unwrap__reference.html">sigc::unwrap_reference< T_type ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::unwrap_reference< T_type > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1unwrap__reference.html">unwrap_reference</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="structsigc_1_1unwrap__reference-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::unwrap_reference< T_type > Struct Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><code>#include <sigc++/reference_wrapper.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:af35cad963fc073623282a2fb9c81f02a"><td class="memItemLeft" align="right" valign="top">typedef T_type </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1unwrap__reference.html#af35cad963fc073623282a2fb9c81f02a">type</a></td></tr>
+<tr class="separator:af35cad963fc073623282a2fb9c81f02a"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="af35cad963fc073623282a2fb9c81f02a"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#af35cad963fc073623282a2fb9c81f02a">◆ </a></span>type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_type <a class="el" href="structsigc_1_1unwrap__reference.html">sigc::unwrap_reference</a>< T_type >::<a class="el" href="structsigc_1_1unwrap__reference.html#af35cad963fc073623282a2fb9c81f02a">type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1unwrap__reference_3_01const__reference__wrapper_3_01T__type_01_4_01_4.html">unwrap_reference< const_reference_wrapper< T_type > ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::unwrap_reference< const_reference_wrapper< T_type > > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1unwrap__reference_3_01const__reference__wrapper_3_01T__type_01_4_01_4.html">sigc::unwrap_reference< const_reference_wrapper< T_type > ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1unwrap__reference_3_01const__reference__wrapper_3_01T__type_01_4_01_4.html#a9820651050b0059841f9a92d9c478ba8">type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1unwrap__reference_3_01const__reference__wrapper_3_01T__type_01_4_01_4.html">sigc::unwrap_reference< const_reference_wrapper< T_type > ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::unwrap_reference< const_reference_wrapper< T_type > > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1unwrap__reference_3_01const__reference__wrapper_3_01T__type_01_4_01_4.html">unwrap_reference< const_reference_wrapper< T_type > ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="structsigc_1_1unwrap__reference_3_01const__reference__wrapper_3_01T__type_01_4_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::unwrap_reference< const_reference_wrapper< T_type > > Struct Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><code>#include <sigc++/reference_wrapper.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a9820651050b0059841f9a92d9c478ba8"><td class="memItemLeft" align="right" valign="top">typedef const T_type & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1unwrap__reference_3_01const__reference__wrapper_3_01T__type_01_4_01_4.html#a9820651050b0059841f9a92d9c478ba8">type</a></td></tr>
+<tr class="separator:a9820651050b0059841f9a92d9c478ba8"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a9820651050b0059841f9a92d9c478ba8"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9820651050b0059841f9a92d9c478ba8">◆ </a></span>type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef const T_type& <a class="el" href="structsigc_1_1unwrap__reference.html">sigc::unwrap_reference</a>< <a class="el" href="structsigc_1_1const__reference__wrapper.html">const_reference_wrapper</a>< T_type > >::<a class="el" href="structsigc_1_1unwrap__reference_3_01const__reference__wrapper_3_01T__type_01_4_01_4.html#a9820651050b0059841f9a92d9c478ba8">type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1unwrap__reference_3_01reference__wrapper_3_01T__type_01_4_01_4.html">unwrap_reference< reference_wrapper< T_type > ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::unwrap_reference< reference_wrapper< T_type > > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1unwrap__reference_3_01reference__wrapper_3_01T__type_01_4_01_4.html">sigc::unwrap_reference< reference_wrapper< T_type > ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1unwrap__reference_3_01reference__wrapper_3_01T__type_01_4_01_4.html#a25182a927492ff79290f9820f7131e58">type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1unwrap__reference_3_01reference__wrapper_3_01T__type_01_4_01_4.html">sigc::unwrap_reference< reference_wrapper< T_type > ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::unwrap_reference< reference_wrapper< T_type > > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1unwrap__reference_3_01reference__wrapper_3_01T__type_01_4_01_4.html">unwrap_reference< reference_wrapper< T_type > ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="structsigc_1_1unwrap__reference_3_01reference__wrapper_3_01T__type_01_4_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::unwrap_reference< reference_wrapper< T_type > > Struct Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><code>#include <sigc++/reference_wrapper.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a25182a927492ff79290f9820f7131e58"><td class="memItemLeft" align="right" valign="top">typedef T_type & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1unwrap__reference_3_01reference__wrapper_3_01T__type_01_4_01_4.html#a25182a927492ff79290f9820f7131e58">type</a></td></tr>
+<tr class="separator:a25182a927492ff79290f9820f7131e58"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a25182a927492ff79290f9820f7131e58"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a25182a927492ff79290f9820f7131e58">◆ </a></span>type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_type& <a class="el" href="structsigc_1_1unwrap__reference.html">sigc::unwrap_reference</a>< <a class="el" href="structsigc_1_1reference__wrapper.html">reference_wrapper</a>< T_type > >::<a class="el" href="structsigc_1_1unwrap__reference_3_01reference__wrapper_3_01T__type_01_4_01_4.html#a25182a927492ff79290f9820f7131e58">type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1unwrap__reference_3_01std_1_1reference__wrapper_3_01T__type_01_4_01_4.html">unwrap_reference< std::reference_wrapper< T_type > ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::unwrap_reference< std::reference_wrapper< T_type > > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1unwrap__reference_3_01std_1_1reference__wrapper_3_01T__type_01_4_01_4.html">sigc::unwrap_reference< std::reference_wrapper< T_type > ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1unwrap__reference_3_01std_1_1reference__wrapper_3_01T__type_01_4_01_4.html#a2a9edeecf0de1843fb4d218f68ae86c4">type</a> typedef</td><td class="entry"><a class="el" href="structsigc_1_1unwrap__reference_3_01std_1_1reference__wrapper_3_01T__type_01_4_01_4.html">sigc::unwrap_reference< std::reference_wrapper< T_type > ></a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::unwrap_reference< std::reference_wrapper< T_type > > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1unwrap__reference_3_01std_1_1reference__wrapper_3_01T__type_01_4_01_4.html">unwrap_reference< std::reference_wrapper< T_type > ></a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-types">Public Types</a> |
+<a href="structsigc_1_1unwrap__reference_3_01std_1_1reference__wrapper_3_01T__type_01_4_01_4-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::unwrap_reference< std::reference_wrapper< T_type > > Struct Template Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><code>#include <sigc++/reference_wrapper.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-types"></a>
+Public Types</h2></td></tr>
+<tr class="memitem:a2a9edeecf0de1843fb4d218f68ae86c4"><td class="memItemLeft" align="right" valign="top">typedef T_type & </td><td class="memItemRight" valign="bottom"><a class="el" href="structsigc_1_1unwrap__reference_3_01std_1_1reference__wrapper_3_01T__type_01_4_01_4.html#a2a9edeecf0de1843fb4d218f68ae86c4">type</a></td></tr>
+<tr class="separator:a2a9edeecf0de1843fb4d218f68ae86c4"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<h2 class="groupheader">Member Typedef Documentation</h2>
+<a id="a2a9edeecf0de1843fb4d218f68ae86c4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a2a9edeecf0de1843fb4d218f68ae86c4">◆ </a></span>type</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_type > </div>
+ <table class="memname">
+ <tr>
+ <td class="memname">typedef T_type& <a class="el" href="structsigc_1_1unwrap__reference.html">sigc::unwrap_reference</a>< <a class="elRef" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a03225.html">std::reference_wrapper</a>< T_type > >::<a class="el" href="structsigc_1_1unwrap__reference_3_01std_1_1reference__wrapper_3_01T__type_01_4_01_4.html#a2a9edeecf0de1843fb4d218f68ae86c4">type</a></td>
+ </tr>
+ </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1visitor.html">visitor</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="headertitle">
+<div class="title">sigc::visitor< T_functor > Member List</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="structsigc_1_1visitor.html">sigc::visitor< T_functor ></a>, including all inherited members.</p>
+<table class="directory">
+ <tr class="even"><td class="entry"><a class="el" href="structsigc_1_1visitor.html#a9fe5d6be845e622a99a0db5d3621d4b3">do_visit_each</a>(const T_action & _A_action, const T_functor & _A_functor)</td><td class="entry"><a class="el" href="structsigc_1_1visitor.html">sigc::visitor< T_functor ></a></td><td class="entry"><span class="mlabel">inline</span><span class="mlabel">static</span></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.9.1"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>libsigc++: sigc::visitor< T_functor > Struct Template Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen-extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">libsigc++
+  <span id="projectnumber">2.10.8</span>
+ </div>
+ </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.9.1 -->
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+ initMenu('',false,false,'search.php','Search');
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<div id="nav-path" class="navpath">
+ <ul>
+<li class="navelem"><a class="el" href="namespacesigc.html">sigc</a></li><li class="navelem"><a class="el" href="structsigc_1_1visitor.html">visitor</a></li> </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+ <div class="summary">
+<a href="#pub-static-methods">Static Public Member Functions</a> |
+<a href="structsigc_1_1visitor-members.html">List of all members</a> </div>
+ <div class="headertitle">
+<div class="title">sigc::visitor< T_functor > Struct Template Reference<div class="ingroups"><a class="el" href="group__sigcfunctors.html">Functors</a></div></div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a class="el" href="structsigc_1_1visitor.html#a9fe5d6be845e622a99a0db5d3621d4b3">sigc::visitor<T_functor>::do_visit_each()</a> performs a functor on each of the targets of a functor.
+ <a href="structsigc_1_1visitor.html#details">More...</a></p>
+
+<p><code>#include <sigc++/visit_each.h></code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-static-methods"></a>
+Static Public Member Functions</h2></td></tr>
+<tr class="memitem:a9fe5d6be845e622a99a0db5d3621d4b3"><td class="memTemplParams" colspan="2">template<class T_action > </td></tr>
+<tr class="memitem:a9fe5d6be845e622a99a0db5d3621d4b3"><td class="memTemplItemLeft" align="right" valign="top">static void </td><td class="memTemplItemRight" valign="bottom"><a class="el" href="structsigc_1_1visitor.html#a9fe5d6be845e622a99a0db5d3621d4b3">do_visit_each</a> (const T_action & _A_action, const T_functor & _A_functor)</td></tr>
+<tr class="separator:a9fe5d6be845e622a99a0db5d3621d4b3"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><h3>template<class T_functor><br />
+struct sigc::visitor< T_functor ></h3>
+
+<p><a class="el" href="structsigc_1_1visitor.html#a9fe5d6be845e622a99a0db5d3621d4b3">sigc::visitor<T_functor>::do_visit_each()</a> performs a functor on each of the targets of a functor. </p>
+<p>All unknown types just call <em>_A_action</em> on them. Add specializations that specialize the <em>T_functor</em> argument for your own functor types, so that subobjects get visited. This is needed to enable auto-disconnection support for your functor types.</p>
+<dl class="section user"><dt>Example:</dt><dd><div class="fragment"><div class="line"><span class="keyword">namespace </span>some_ns</div>
+<div class="line">{</div>
+<div class="line"> <span class="keyword">struct </span>some_functor</div>
+<div class="line"> {</div>
+<div class="line"> <span class="keywordtype">void</span> operator()() {}</div>
+<div class="line"> some_possibly_sigc_trackable_derived_type some_data_member;</div>
+<div class="line"> some_other_functor_type some_other_functor;</div>
+<div class="line"> };</div>
+<div class="line">}</div>
+<div class="line"> </div>
+<div class="line"><span class="keyword">namespace </span><a class="code" href="namespacesigc.html">sigc</a></div>
+<div class="line">{</div>
+<div class="line"> <span class="keyword">template</span> <></div>
+<div class="line"> <span class="keyword">struct </span>visitor<some_ns::some_functor></div>
+<div class="line"> {</div>
+<div class="line"> <span class="keyword">template</span> <<span class="keyword">class</span> T_action></div>
+<div class="line"> <span class="keyword">static</span> <span class="keywordtype">void</span> <a class="code" href="structsigc_1_1visitor.html#a9fe5d6be845e622a99a0db5d3621d4b3">do_visit_each</a>(<span class="keyword">const</span> T_action& _A_action,</div>
+<div class="line"> <span class="keyword">const</span> some_ns::some_functor& _A_target)</div>
+<div class="line"> {</div>
+<div class="line"> <a class="code" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404">sigc::visit_each</a>(_A_action, _A_target.some_data_member);</div>
+<div class="line"> <a class="code" href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404">sigc::visit_each</a>(_A_action, _A_target.some_other_functor);</div>
+<div class="line"> }</div>
+<div class="line"> };</div>
+<div class="line">}</div>
+<div class="ttc" id="agroup__sigcfunctors_html_ga64cb7832acc1e58efb5ffe0b4f5e9404"><div class="ttname"><a href="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404">sigc::visit_each</a></div><div class="ttdeci">void visit_each(const T_action &_A_action, const T_functor &_A_functor)</div><div class="ttdoc">This function performs a functor on each of the targets of a functor.</div><div class="ttdef"><b>Definition:</b> visit_each.h:169</div></div>
+<div class="ttc" id="anamespacesigc_html"><div class="ttname"><a href="namespacesigc.html">sigc</a></div><div class="ttdoc">The libsigc++ namespace.</div><div class="ttdef"><b>Definition:</b> limit_reference.h:12</div></div>
+<div class="ttc" id="astructsigc_1_1visitor_html_a9fe5d6be845e622a99a0db5d3621d4b3"><div class="ttname"><a href="structsigc_1_1visitor.html#a9fe5d6be845e622a99a0db5d3621d4b3">sigc::visitor::do_visit_each</a></div><div class="ttdeci">static void do_visit_each(const T_action &_A_action, const T_functor &_A_functor)</div><div class="ttdef"><b>Definition:</b> visit_each.h:158</div></div>
+</div><!-- fragment --> </dd></dl>
+</div><h2 class="groupheader">Member Function Documentation</h2>
+<a id="a9fe5d6be845e622a99a0db5d3621d4b3"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a9fe5d6be845e622a99a0db5d3621d4b3">◆ </a></span>do_visit_each()</h2>
+
+<div class="memitem">
+<div class="memproto">
+<div class="memtemplate">
+template <class T_functor > </div>
+<div class="memtemplate">
+template <class T_action > </div>
+<table class="mlabels">
+ <tr>
+ <td class="mlabels-left">
+ <table class="memname">
+ <tr>
+ <td class="memname">static void <a class="el" href="structsigc_1_1visitor.html">sigc::visitor</a>< T_functor >::do_visit_each </td>
+ <td>(</td>
+ <td class="paramtype">const T_action & </td>
+ <td class="paramname"><em>_A_action</em>, </td>
+ </tr>
+ <tr>
+ <td class="paramkey"></td>
+ <td></td>
+ <td class="paramtype">const T_functor & </td>
+ <td class="paramname"><em>_A_functor</em> </td>
+ </tr>
+ <tr>
+ <td></td>
+ <td>)</td>
+ <td></td><td></td>
+ </tr>
+ </table>
+ </td>
+ <td class="mlabels-right">
+<span class="mlabels"><span class="mlabel">inline</span><span class="mlabel">static</span></span> </td>
+ </tr>
+</table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Fri Feb 11 2022 15:40:59 for libsigc++ by <a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
+</small></address>
+</body>
+</html>
--- /dev/null
+.sm{position:relative;z-index:9999}.sm,.sm ul,.sm li{display:block;list-style:none;margin:0;padding:0;line-height:normal;direction:ltr;text-align:left;-webkit-tap-highlight-color:rgba(0,0,0,0)}.sm-rtl,.sm-rtl ul,.sm-rtl li{direction:rtl;text-align:right}.sm>li>h1,.sm>li>h2,.sm>li>h3,.sm>li>h4,.sm>li>h5,.sm>li>h6{margin:0;padding:0}.sm ul{display:none}.sm li,.sm a{position:relative}.sm a{display:block}.sm a.disabled{cursor:not-allowed}.sm:after{content:"\00a0";display:block;height:0;font:0px/0 serif;clear:both;visibility:hidden;overflow:hidden}.sm,.sm *,.sm *:before,.sm *:after{-moz-box-sizing:border-box;-webkit-box-sizing:border-box;box-sizing:border-box}.sm-dox{background-image:url("tab_b.png")}.sm-dox a,.sm-dox a:focus,.sm-dox a:hover,.sm-dox a:active{padding:0px 12px;padding-right:43px;font-family:"Lucida Grande","Geneva","Helvetica",Arial,sans-serif;font-size:13px;font-weight:bold;line-height:36px;text-decoration:none;text-shadow:0px 1px 1px rgba(255,255,255,0.9);color:#283A5D;outline:none}.sm-dox a:hover{background-image:url("tab_a.png");background-repeat:repeat-x;color:#fff;text-shadow:0px 1px 1px #000}.sm-dox a.current{color:#D23600}.sm-dox a.disabled{color:#bbb}.sm-dox a span.sub-arrow{position:absolute;top:50%;margin-top:-14px;left:auto;right:3px;width:28px;height:28px;overflow:hidden;font:bold 12px/28px monospace !important;text-align:center;text-shadow:none;background:rgba(255,255,255,0.5);border-radius:5px}.sm-dox a.highlighted span.sub-arrow:before{display:block;content:'-'}.sm-dox>li:first-child>a,.sm-dox>li:first-child>:not(ul) a{border-radius:5px 5px 0 0}.sm-dox>li:last-child>a,.sm-dox>li:last-child>*:not(ul) a,.sm-dox>li:last-child>ul,.sm-dox>li:last-child>ul>li:last-child>a,.sm-dox>li:last-child>ul>li:last-child>*:not(ul) a,.sm-dox>li:last-child>ul>li:last-child>ul,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul{border-radius:0 0 5px 5px}.sm-dox>li:last-child>a.highlighted,.sm-dox>li:last-child>*:not(ul) a.highlighted,.sm-dox>li:last-child>ul>li:last-child>a.highlighted,.sm-dox>li:last-child>ul>li:last-child>*:not(ul) a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a.highlighted{border-radius:0}.sm-dox ul{background:rgba(162,162,162,0.1)}.sm-dox ul a,.sm-dox ul a:focus,.sm-dox ul a:hover,.sm-dox ul a:active{font-size:12px;border-left:8px solid transparent;line-height:36px;text-shadow:none;background-color:white;background-image:none}.sm-dox ul a:hover{background-image:url("tab_a.png");background-repeat:repeat-x;color:#fff;text-shadow:0px 1px 1px #000}.sm-dox ul ul a,.sm-dox ul ul a:hover,.sm-dox ul ul a:focus,.sm-dox ul ul a:active{border-left:16px solid transparent}.sm-dox ul ul ul a,.sm-dox ul ul ul a:hover,.sm-dox ul ul ul a:focus,.sm-dox ul ul ul a:active{border-left:24px solid transparent}.sm-dox ul ul ul ul a,.sm-dox ul ul ul ul a:hover,.sm-dox ul ul ul ul a:focus,.sm-dox ul ul ul ul a:active{border-left:32px solid transparent}.sm-dox ul ul ul ul ul a,.sm-dox ul ul ul ul ul a:hover,.sm-dox ul ul ul ul ul a:focus,.sm-dox ul ul ul ul ul a:active{border-left:40px solid transparent}@media (min-width: 768px){.sm-dox ul{position:absolute;width:12em}.sm-dox li{float:left}.sm-dox.sm-rtl li{float:right}.sm-dox ul li,.sm-dox.sm-rtl ul li,.sm-dox.sm-vertical li{float:none}.sm-dox a{white-space:nowrap}.sm-dox ul a,.sm-dox.sm-vertical a{white-space:normal}.sm-dox .sm-nowrap>li>a,.sm-dox .sm-nowrap>li>:not(ul) a{white-space:nowrap}.sm-dox{padding:0 10px;background-image:url("tab_b.png");line-height:36px}.sm-dox a span.sub-arrow{top:50%;margin-top:-2px;right:12px;width:0;height:0;border-width:4px;border-style:solid dashed dashed dashed;border-color:#283A5D transparent transparent transparent;background:transparent;border-radius:0}.sm-dox a,.sm-dox a:focus,.sm-dox a:active,.sm-dox a:hover,.sm-dox a.highlighted{padding:0px 12px;background-image:url("tab_s.png");background-repeat:no-repeat;background-position:right;border-radius:0 !important}.sm-dox a:hover{background-image:url("tab_a.png");background-repeat:repeat-x;color:#fff;text-shadow:0px 1px 1px #000}.sm-dox a:hover span.sub-arrow{border-color:#fff transparent transparent transparent}.sm-dox a.has-submenu{padding-right:24px}.sm-dox li{border-top:0}.sm-dox>li>ul:before,.sm-dox>li>ul:after{content:'';position:absolute;top:-18px;left:30px;width:0;height:0;overflow:hidden;border-width:9px;border-style:dashed dashed solid dashed;border-color:transparent transparent #bbb transparent}.sm-dox>li>ul:after{top:-16px;left:31px;border-width:8px;border-color:transparent transparent #fff transparent}.sm-dox ul{border:1px solid #bbb;padding:5px 0;background:#fff;border-radius:5px !important;box-shadow:0 5px 9px rgba(0,0,0,0.2)}.sm-dox ul a span.sub-arrow{right:8px;top:50%;margin-top:-5px;border-width:5px;border-color:transparent transparent transparent #555;border-style:dashed dashed dashed solid}.sm-dox ul a,.sm-dox ul a:hover,.sm-dox ul a:focus,.sm-dox ul a:active,.sm-dox ul a.highlighted{color:#555;background-image:none;border:0 !important;color:#555;background-image:none}.sm-dox ul a:hover{background-image:url("tab_a.png");background-repeat:repeat-x;color:#fff;text-shadow:0px 1px 1px #000}.sm-dox ul a:hover span.sub-arrow{border-color:transparent transparent transparent #fff}.sm-dox span.scroll-up,.sm-dox span.scroll-down{position:absolute;display:none;visibility:hidden;overflow:hidden;background:#fff;height:36px}.sm-dox span.scroll-up:hover,.sm-dox span.scroll-down:hover{background:#eee}.sm-dox span.scroll-up:hover span.scroll-up-arrow,.sm-dox span.scroll-up:hover span.scroll-down-arrow{border-color:transparent transparent #D23600 transparent}.sm-dox span.scroll-down:hover span.scroll-down-arrow{border-color:#D23600 transparent transparent transparent}.sm-dox span.scroll-up-arrow,.sm-dox span.scroll-down-arrow{position:absolute;top:0;left:50%;margin-left:-6px;width:0;height:0;overflow:hidden;border-width:6px;border-style:dashed dashed solid dashed;border-color:transparent transparent #555 transparent}.sm-dox span.scroll-down-arrow{top:8px;border-style:solid dashed dashed dashed;border-color:#555 transparent transparent transparent}.sm-dox.sm-rtl a.has-submenu{padding-right:12px;padding-left:24px}.sm-dox.sm-rtl a span.sub-arrow{right:auto;left:12px}.sm-dox.sm-rtl.sm-vertical a.has-submenu{padding:10px 20px}.sm-dox.sm-rtl.sm-vertical a span.sub-arrow{right:auto;left:8px;border-style:dashed solid dashed dashed;border-color:transparent #555 transparent transparent}.sm-dox.sm-rtl>li>ul:before{left:auto;right:30px}.sm-dox.sm-rtl>li>ul:after{left:auto;right:31px}.sm-dox.sm-rtl ul a.has-submenu{padding:10px 20px !important}.sm-dox.sm-rtl ul a span.sub-arrow{right:auto;left:8px;border-style:dashed solid dashed dashed;border-color:transparent #555 transparent transparent}.sm-dox.sm-vertical{padding:10px 0;border-radius:5px}.sm-dox.sm-vertical a{padding:10px 20px}.sm-dox.sm-vertical a:hover,.sm-dox.sm-vertical a:focus,.sm-dox.sm-vertical a:active,.sm-dox.sm-vertical a.highlighted{background:#fff}.sm-dox.sm-vertical a.disabled{background-image:url("tab_b.png")}.sm-dox.sm-vertical a span.sub-arrow{right:8px;top:50%;margin-top:-5px;border-width:5px;border-style:dashed dashed dashed solid;border-color:transparent transparent transparent #555}.sm-dox.sm-vertical>li>ul:before,.sm-dox.sm-vertical>li>ul:after{display:none}.sm-dox.sm-vertical ul a{padding:10px 20px}.sm-dox.sm-vertical ul a:hover,.sm-dox.sm-vertical ul a:focus,.sm-dox.sm-vertical ul a:active,.sm-dox.sm-vertical ul a.highlighted{background:#eee}.sm-dox.sm-vertical ul a.disabled{background:#fff}}
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<book xmlns="http://www.devhelp.net/book" title="libsigc++ Reference Manual" name="libsigc++-2.0" base="html" link="index.html" version="2" language="c++">
+ <chapters>
+ <sub name="Modules" link="modules.html">
+ <sub name="Adaptors" link="group__adaptors.html">
+ <sub name="bind(), bind_return()" link="group__bind.html"/>
+ <sub name="compose()" link="group__compose.html"/>
+ <sub name="exception_catch()" link="group__exception__catch.html"/>
+ <sub name="hide(), hide_return()" link="group__hide.html"/>
+ <sub name="retype(), retype_return()" link="group__retype.html"/>
+ <sub name="track_obj()" link="group__track__obj.html"/>
+ </sub>
+ <sub name="Functors" link="group__sigcfunctors.html">
+ <sub name="mem_fun()" link="group__mem__fun.html"/>
+ <sub name="ptr_fun()" link="group__ptr__fun.html"/>
+ <sub name="Slots" link="group__slot.html"/>
+ </sub>
+ <sub name="Signals" link="group__signal.html"/>
+ </sub>
+ <sub name="Namespaces" link="namespaces.html">
+ <sub name="sigc" link="namespacesigc.html"/>
+ </sub>
+ <sub name="Classes" link="classes.html">
+ <sub name="adapts< T_setter >" link="structsigc_1_1adapts.html"/>
+ <sub name="bound_argument< T_bound >" link="classsigc_1_1bound__argument.html"/>
+ <sub name="bound_argument< T_return >" link="classsigc_1_1bound__argument.html"/>
+ <sub name="bound_argument< T_type1 >" link="classsigc_1_1bound__argument.html"/>
+ <sub name="const_limit_reference< T_obj >" link="classsigc_1_1const__limit__reference.html"/>
+ <sub name="const_limit_reference< T_wrapped >" link="classsigc_1_1const__limit__reference.html"/>
+ <sub name="const_volatile_limit_reference< T_obj >" link="classsigc_1_1const__volatile__limit__reference.html"/>
+ <sub name="limit_reference< T_obj >" link="classsigc_1_1limit__reference.html"/>
+ <sub name="limit_reference< T_wrapped >" link="classsigc_1_1limit__reference.html"/>
+ <sub name="sigc" link="namespacesigc.html">
+ <sub name="adaptor_base" link="structsigc_1_1adaptor__base.html"/>
+ <sub name="adaptor_functor" link="structsigc_1_1adaptor__functor.html"/>
+ <sub name="adaptor_trait" link="structsigc_1_1adaptor__trait.html"/>
+ <sub name="adaptor_trait< T_functor, false >" link="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html"/>
+ <sub name="adaptor_trait< T_functor, true >" link="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html"/>
+ <sub name="adapts" link="structsigc_1_1adapts.html"/>
+ <sub name="bind_functor" link="structsigc_1_1bind__functor.html"/>
+ <sub name="bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil >" link="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html"/>
+ <sub name="bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil >" link="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html"/>
+ <sub name="bind_return_functor" link="structsigc_1_1bind__return__functor.html"/>
+ <sub name="bound_argument" link="classsigc_1_1bound__argument.html"/>
+ <sub name="bound_argument< const_reference_wrapper< T_wrapped > >" link="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html"/>
+ <sub name="bound_argument< reference_wrapper< T_wrapped > >" link="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html"/>
+ <sub name="bound_argument< std::reference_wrapper< T_wrapped > >" link="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html"/>
+ <sub name="bound_const_mem_functor0" link="classsigc_1_1bound__const__mem__functor0.html"/>
+ <sub name="bound_const_mem_functor1" link="classsigc_1_1bound__const__mem__functor1.html"/>
+ <sub name="bound_const_mem_functor2" link="classsigc_1_1bound__const__mem__functor2.html"/>
+ <sub name="bound_const_mem_functor3" link="classsigc_1_1bound__const__mem__functor3.html"/>
+ <sub name="bound_const_mem_functor4" link="classsigc_1_1bound__const__mem__functor4.html"/>
+ <sub name="bound_const_mem_functor5" link="classsigc_1_1bound__const__mem__functor5.html"/>
+ <sub name="bound_const_mem_functor6" link="classsigc_1_1bound__const__mem__functor6.html"/>
+ <sub name="bound_const_mem_functor7" link="classsigc_1_1bound__const__mem__functor7.html"/>
+ <sub name="bound_const_volatile_mem_functor0" link="classsigc_1_1bound__const__volatile__mem__functor0.html"/>
+ <sub name="bound_const_volatile_mem_functor1" link="classsigc_1_1bound__const__volatile__mem__functor1.html"/>
+ <sub name="bound_const_volatile_mem_functor2" link="classsigc_1_1bound__const__volatile__mem__functor2.html"/>
+ <sub name="bound_const_volatile_mem_functor3" link="classsigc_1_1bound__const__volatile__mem__functor3.html"/>
+ <sub name="bound_const_volatile_mem_functor4" link="classsigc_1_1bound__const__volatile__mem__functor4.html"/>
+ <sub name="bound_const_volatile_mem_functor5" link="classsigc_1_1bound__const__volatile__mem__functor5.html"/>
+ <sub name="bound_const_volatile_mem_functor6" link="classsigc_1_1bound__const__volatile__mem__functor6.html"/>
+ <sub name="bound_const_volatile_mem_functor7" link="classsigc_1_1bound__const__volatile__mem__functor7.html"/>
+ <sub name="bound_mem_functor0" link="classsigc_1_1bound__mem__functor0.html"/>
+ <sub name="bound_mem_functor1" link="classsigc_1_1bound__mem__functor1.html"/>
+ <sub name="bound_mem_functor2" link="classsigc_1_1bound__mem__functor2.html"/>
+ <sub name="bound_mem_functor3" link="classsigc_1_1bound__mem__functor3.html"/>
+ <sub name="bound_mem_functor4" link="classsigc_1_1bound__mem__functor4.html"/>
+ <sub name="bound_mem_functor5" link="classsigc_1_1bound__mem__functor5.html"/>
+ <sub name="bound_mem_functor6" link="classsigc_1_1bound__mem__functor6.html"/>
+ <sub name="bound_mem_functor7" link="classsigc_1_1bound__mem__functor7.html"/>
+ <sub name="bound_volatile_mem_functor0" link="classsigc_1_1bound__volatile__mem__functor0.html"/>
+ <sub name="bound_volatile_mem_functor1" link="classsigc_1_1bound__volatile__mem__functor1.html"/>
+ <sub name="bound_volatile_mem_functor2" link="classsigc_1_1bound__volatile__mem__functor2.html"/>
+ <sub name="bound_volatile_mem_functor3" link="classsigc_1_1bound__volatile__mem__functor3.html"/>
+ <sub name="bound_volatile_mem_functor4" link="classsigc_1_1bound__volatile__mem__functor4.html"/>
+ <sub name="bound_volatile_mem_functor5" link="classsigc_1_1bound__volatile__mem__functor5.html"/>
+ <sub name="bound_volatile_mem_functor6" link="classsigc_1_1bound__volatile__mem__functor6.html"/>
+ <sub name="bound_volatile_mem_functor7" link="classsigc_1_1bound__volatile__mem__functor7.html"/>
+ <sub name="can_deduce_result_type_with_decltype" link="classsigc_1_1can__deduce__result__type__with__decltype.html"/>
+ <sub name="compose1_functor" link="structsigc_1_1compose1__functor.html"/>
+ <sub name="compose2_functor" link="structsigc_1_1compose2__functor.html"/>
+ <sub name="connection" link="structsigc_1_1connection.html"/>
+ <sub name="const_limit_reference" link="classsigc_1_1const__limit__reference.html"/>
+ <sub name="const_limit_reference< T_type, true >" link="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html"/>
+ <sub name="const_mem_functor0" link="classsigc_1_1const__mem__functor0.html"/>
+ <sub name="const_mem_functor1" link="classsigc_1_1const__mem__functor1.html"/>
+ <sub name="const_mem_functor2" link="classsigc_1_1const__mem__functor2.html"/>
+ <sub name="const_mem_functor3" link="classsigc_1_1const__mem__functor3.html"/>
+ <sub name="const_mem_functor4" link="classsigc_1_1const__mem__functor4.html"/>
+ <sub name="const_mem_functor5" link="classsigc_1_1const__mem__functor5.html"/>
+ <sub name="const_mem_functor6" link="classsigc_1_1const__mem__functor6.html"/>
+ <sub name="const_mem_functor7" link="classsigc_1_1const__mem__functor7.html"/>
+ <sub name="const_reference_wrapper" link="structsigc_1_1const__reference__wrapper.html"/>
+ <sub name="const_volatile_limit_reference" link="classsigc_1_1const__volatile__limit__reference.html"/>
+ <sub name="const_volatile_limit_reference< T_type, true >" link="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html"/>
+ <sub name="const_volatile_mem_functor0" link="classsigc_1_1const__volatile__mem__functor0.html"/>
+ <sub name="const_volatile_mem_functor1" link="classsigc_1_1const__volatile__mem__functor1.html"/>
+ <sub name="const_volatile_mem_functor2" link="classsigc_1_1const__volatile__mem__functor2.html"/>
+ <sub name="const_volatile_mem_functor3" link="classsigc_1_1const__volatile__mem__functor3.html"/>
+ <sub name="const_volatile_mem_functor4" link="classsigc_1_1const__volatile__mem__functor4.html"/>
+ <sub name="const_volatile_mem_functor5" link="classsigc_1_1const__volatile__mem__functor5.html"/>
+ <sub name="const_volatile_mem_functor6" link="classsigc_1_1const__volatile__mem__functor6.html"/>
+ <sub name="const_volatile_mem_functor7" link="classsigc_1_1const__volatile__mem__functor7.html"/>
+ <sub name="deduce_result_type" link="structsigc_1_1deduce__result__type.html"/>
+ <sub name="exception_catch_functor" link="structsigc_1_1exception__catch__functor.html"/>
+ <sub name="exception_catch_functor< T_functor, T_catcher, void >" link="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html"/>
+ <sub name="functor_base" link="structsigc_1_1functor__base.html"/>
+ <sub name="functor_trait" link="structsigc_1_1functor__trait.html"/>
+ <sub name="hide_functor" link="structsigc_1_1hide__functor.html"/>
+ <sub name="hide_functor< 0, T_functor >" link="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html"/>
+ <sub name="hide_functor<-1, T_functor >" link="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html"/>
+ <sub name="limit_reference" link="classsigc_1_1limit__reference.html"/>
+ <sub name="limit_reference< T_type, true >" link="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html"/>
+ <sub name="mem_functor0" link="classsigc_1_1mem__functor0.html"/>
+ <sub name="mem_functor1" link="classsigc_1_1mem__functor1.html"/>
+ <sub name="mem_functor2" link="classsigc_1_1mem__functor2.html"/>
+ <sub name="mem_functor3" link="classsigc_1_1mem__functor3.html"/>
+ <sub name="mem_functor4" link="classsigc_1_1mem__functor4.html"/>
+ <sub name="mem_functor5" link="classsigc_1_1mem__functor5.html"/>
+ <sub name="mem_functor6" link="classsigc_1_1mem__functor6.html"/>
+ <sub name="mem_functor7" link="classsigc_1_1mem__functor7.html"/>
+ <sub name="nil" link="structsigc_1_1nil.html"/>
+ <sub name="pointer_functor0" link="classsigc_1_1pointer__functor0.html"/>
+ <sub name="pointer_functor1" link="classsigc_1_1pointer__functor1.html"/>
+ <sub name="pointer_functor2" link="classsigc_1_1pointer__functor2.html"/>
+ <sub name="pointer_functor3" link="classsigc_1_1pointer__functor3.html"/>
+ <sub name="pointer_functor4" link="classsigc_1_1pointer__functor4.html"/>
+ <sub name="pointer_functor5" link="classsigc_1_1pointer__functor5.html"/>
+ <sub name="pointer_functor6" link="classsigc_1_1pointer__functor6.html"/>
+ <sub name="pointer_functor7" link="classsigc_1_1pointer__functor7.html"/>
+ <sub name="reference_wrapper" link="structsigc_1_1reference__wrapper.html"/>
+ <sub name="retype_functor" link="structsigc_1_1retype__functor.html"/>
+ <sub name="retype_return_functor" link="structsigc_1_1retype__return__functor.html"/>
+ <sub name="retype_return_functor< void, T_functor >" link="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html"/>
+ <sub name="signal" link="classsigc_1_1signal.html">
+ <sub name="accumulated" link="classsigc_1_1signal_1_1accumulated.html"/>
+ </sub>
+ <sub name="signal0" link="classsigc_1_1signal0.html"/>
+ <sub name="signal1" link="classsigc_1_1signal1.html"/>
+ <sub name="signal2" link="classsigc_1_1signal2.html"/>
+ <sub name="signal3" link="classsigc_1_1signal3.html"/>
+ <sub name="signal4" link="classsigc_1_1signal4.html"/>
+ <sub name="signal5" link="classsigc_1_1signal5.html"/>
+ <sub name="signal6" link="classsigc_1_1signal6.html"/>
+ <sub name="signal7" link="classsigc_1_1signal7.html"/>
+ <sub name="signal_base" link="structsigc_1_1signal__base.html"/>
+ <sub name="signal< T_return()>" link="classsigc_1_1signal_3_01T__return_07_08_4.html">
+ <sub name="accumulated" link="classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html"/>
+ </sub>
+ <sub name="signal< T_return, nil, nil, nil, nil, nil, nil, nil >" link="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">
+ <sub name="accumulated" link="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html"/>
+ </sub>
+ <sub name="signal< T_return(T_arg1)>" link="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html">
+ <sub name="accumulated" link="classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html"/>
+ </sub>
+ <sub name="signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">
+ <sub name="accumulated" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html"/>
+ </sub>
+ <sub name="signal< T_return(T_arg1, T_arg2)>" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html">
+ <sub name="accumulated" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html"/>
+ </sub>
+ <sub name="signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">
+ <sub name="accumulated" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html"/>
+ </sub>
+ <sub name="signal< T_return(T_arg1, T_arg2, T_arg3)>" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html">
+ <sub name="accumulated" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html"/>
+ </sub>
+ <sub name="signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html">
+ <sub name="accumulated" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html"/>
+ </sub>
+ <sub name="signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html">
+ <sub name="accumulated" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html"/>
+ </sub>
+ <sub name="signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html">
+ <sub name="accumulated" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html"/>
+ </sub>
+ <sub name="signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html">
+ <sub name="accumulated" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html"/>
+ </sub>
+ <sub name="signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html">
+ <sub name="accumulated" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html"/>
+ </sub>
+ <sub name="signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html">
+ <sub name="accumulated" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html"/>
+ </sub>
+ <sub name="signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html">
+ <sub name="accumulated" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html"/>
+ </sub>
+ <sub name="signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html">
+ <sub name="accumulated" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html"/>
+ </sub>
+ <sub name="slot" link="classsigc_1_1slot.html"/>
+ <sub name="slot0" link="classsigc_1_1slot0.html"/>
+ <sub name="slot1" link="classsigc_1_1slot1.html"/>
+ <sub name="slot2" link="classsigc_1_1slot2.html"/>
+ <sub name="slot3" link="classsigc_1_1slot3.html"/>
+ <sub name="slot4" link="classsigc_1_1slot4.html"/>
+ <sub name="slot5" link="classsigc_1_1slot5.html"/>
+ <sub name="slot6" link="classsigc_1_1slot6.html"/>
+ <sub name="slot7" link="classsigc_1_1slot7.html"/>
+ <sub name="slot_base" link="classsigc_1_1slot__base.html"/>
+ <sub name="slot_const_iterator" link="structsigc_1_1slot__const__iterator.html"/>
+ <sub name="slot_iterator" link="structsigc_1_1slot__iterator.html"/>
+ <sub name="slot_list" link="structsigc_1_1slot__list.html"/>
+ <sub name="slot< T_return, nil, nil, nil, nil, nil, nil, nil >" link="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html"/>
+ <sub name="slot< T_return(T_arg...)>" link="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html"/>
+ <sub name="slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil >" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html"/>
+ <sub name="slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html"/>
+ <sub name="slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html"/>
+ <sub name="slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html"/>
+ <sub name="slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html"/>
+ <sub name="slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html"/>
+ <sub name="trackable" link="structsigc_1_1trackable.html"/>
+ <sub name="track_obj_functor1" link="classsigc_1_1track__obj__functor1.html"/>
+ <sub name="track_obj_functor2" link="classsigc_1_1track__obj__functor2.html"/>
+ <sub name="track_obj_functor3" link="classsigc_1_1track__obj__functor3.html"/>
+ <sub name="track_obj_functor4" link="classsigc_1_1track__obj__functor4.html"/>
+ <sub name="track_obj_functor5" link="classsigc_1_1track__obj__functor5.html"/>
+ <sub name="track_obj_functor6" link="classsigc_1_1track__obj__functor6.html"/>
+ <sub name="track_obj_functor7" link="classsigc_1_1track__obj__functor7.html"/>
+ <sub name="type_trait" link="structsigc_1_1type__trait.html"/>
+ <sub name="type_trait< const T_type & >" link="structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html"/>
+ <sub name="type_trait< T_type & >" link="structsigc_1_1type__trait_3_01T__type_01_6_01_4.html"/>
+ <sub name="type_trait< T_type[N]>" link="structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html"/>
+ <sub name="type_trait< void >" link="structsigc_1_1type__trait_3_01void_01_4.html"/>
+ <sub name="unwrap_reference" link="structsigc_1_1unwrap__reference.html"/>
+ <sub name="unwrap_reference< const_reference_wrapper< T_type > >" link="structsigc_1_1unwrap__reference_3_01const__reference__wrapper_3_01T__type_01_4_01_4.html"/>
+ <sub name="unwrap_reference< reference_wrapper< T_type > >" link="structsigc_1_1unwrap__reference_3_01reference__wrapper_3_01T__type_01_4_01_4.html"/>
+ <sub name="unwrap_reference< std::reference_wrapper< T_type > >" link="structsigc_1_1unwrap__reference_3_01std_1_1reference__wrapper_3_01T__type_01_4_01_4.html"/>
+ <sub name="visitor" link="structsigc_1_1visitor.html"/>
+ <sub name="volatile_limit_reference" link="classsigc_1_1volatile__limit__reference.html"/>
+ <sub name="volatile_limit_reference< T_type, true >" link="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html"/>
+ <sub name="volatile_mem_functor0" link="classsigc_1_1volatile__mem__functor0.html"/>
+ <sub name="volatile_mem_functor1" link="classsigc_1_1volatile__mem__functor1.html"/>
+ <sub name="volatile_mem_functor2" link="classsigc_1_1volatile__mem__functor2.html"/>
+ <sub name="volatile_mem_functor3" link="classsigc_1_1volatile__mem__functor3.html"/>
+ <sub name="volatile_mem_functor4" link="classsigc_1_1volatile__mem__functor4.html"/>
+ <sub name="volatile_mem_functor5" link="classsigc_1_1volatile__mem__functor5.html"/>
+ <sub name="volatile_mem_functor6" link="classsigc_1_1volatile__mem__functor6.html"/>
+ <sub name="volatile_mem_functor7" link="classsigc_1_1volatile__mem__functor7.html"/>
+ </sub>
+ <sub name="signal0< T_return, nil >" link="classsigc_1_1signal0.html"/>
+ <sub name="signal0< T_return, T_accumulator >" link="classsigc_1_1signal0.html"/>
+ <sub name="signal1< T_return, T_arg1, nil >" link="classsigc_1_1signal1.html"/>
+ <sub name="signal1< T_return, T_arg1, T_accumulator >" link="classsigc_1_1signal1.html"/>
+ <sub name="signal2< T_return, T_arg1, T_arg2, nil >" link="classsigc_1_1signal2.html"/>
+ <sub name="signal2< T_return, T_arg1, T_arg2, T_accumulator >" link="classsigc_1_1signal2.html"/>
+ <sub name="signal3< T_return, T_arg1, T_arg2, T_arg3, nil >" link="classsigc_1_1signal3.html"/>
+ <sub name="signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >" link="classsigc_1_1signal3.html"/>
+ <sub name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil >" link="classsigc_1_1signal4.html"/>
+ <sub name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >" link="classsigc_1_1signal4.html"/>
+ <sub name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil >" link="classsigc_1_1signal5.html"/>
+ <sub name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >" link="classsigc_1_1signal5.html"/>
+ <sub name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >" link="classsigc_1_1signal6.html"/>
+ <sub name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >" link="classsigc_1_1signal6.html"/>
+ <sub name="signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil >" link="classsigc_1_1signal7.html"/>
+ <sub name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil >" link="classsigc_1_1signal7.html"/>
+ <sub name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >" link="classsigc_1_1signal7.html"/>
+ <sub name="slot7< T_return, nil, nil, nil, nil, nil, nil, nil >" link="classsigc_1_1slot7.html"/>
+ <sub name="volatile_limit_reference< T_obj >" link="classsigc_1_1volatile__limit__reference.html"/>
+ </sub>
+ </chapters>
+ <functions>
+ <keyword type="struct" name="adapts< T_setter >" link="structsigc_1_1adapts.html"/>
+ <keyword name="adapts< T_setter >::adaptor_type" link="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248" type="typedef"/>
+ <keyword name="adapts< T_setter >::result_type" link="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d" type="typedef"/>
+ <keyword name="adapts< T_setter >::adapts" link="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8" type="function"/>
+ <keyword type="struct" name="bound_argument< T_bound >" link="classsigc_1_1bound__argument.html"/>
+ <keyword name="bound_argument< T_bound >::bound_argument" link="classsigc_1_1bound__argument.html#a495bb69a41b38eda5d6ace5a36807a37" type="function"/>
+ <keyword name="bound_argument< T_bound >::invoke" link="classsigc_1_1bound__argument.html#af1cf20526bade89328a1ed398055bbba" type="function"/>
+ <keyword name="bound_argument< T_bound >::visit" link="classsigc_1_1bound__argument.html#ab29e53c5e983c45e4963e0ecace26465" type="function"/>
+ <keyword type="struct" name="bound_argument< T_return >" link="classsigc_1_1bound__argument.html"/>
+ <keyword name="bound_argument< T_return >::bound_argument" link="classsigc_1_1bound__argument.html#a495bb69a41b38eda5d6ace5a36807a37" type="function"/>
+ <keyword name="bound_argument< T_return >::invoke" link="classsigc_1_1bound__argument.html#af1cf20526bade89328a1ed398055bbba" type="function"/>
+ <keyword name="bound_argument< T_return >::visit" link="classsigc_1_1bound__argument.html#ab29e53c5e983c45e4963e0ecace26465" type="function"/>
+ <keyword type="struct" name="bound_argument< T_type1 >" link="classsigc_1_1bound__argument.html"/>
+ <keyword name="bound_argument< T_type1 >::bound_argument" link="classsigc_1_1bound__argument.html#a495bb69a41b38eda5d6ace5a36807a37" type="function"/>
+ <keyword name="bound_argument< T_type1 >::invoke" link="classsigc_1_1bound__argument.html#af1cf20526bade89328a1ed398055bbba" type="function"/>
+ <keyword name="bound_argument< T_type1 >::visit" link="classsigc_1_1bound__argument.html#ab29e53c5e983c45e4963e0ecace26465" type="function"/>
+ <keyword type="struct" name="const_limit_reference< T_obj >" link="classsigc_1_1const__limit__reference.html"/>
+ <keyword name="const_limit_reference< T_obj >::const_limit_reference" link="classsigc_1_1const__limit__reference.html#acee8a4c09720730cd5f66696fd018b4c" type="function"/>
+ <keyword name="const_limit_reference< T_obj >::invoke" link="classsigc_1_1const__limit__reference.html#abb05a4234000dbf4a256b446d3ef580d" type="function"/>
+ <keyword name="const_limit_reference< T_obj >::visit" link="classsigc_1_1const__limit__reference.html#aa7486303566b2a9a74e55561083ed3d9" type="function"/>
+ <keyword type="struct" name="const_limit_reference< T_wrapped >" link="classsigc_1_1const__limit__reference.html"/>
+ <keyword name="const_limit_reference< T_wrapped >::const_limit_reference" link="classsigc_1_1const__limit__reference.html#acee8a4c09720730cd5f66696fd018b4c" type="function"/>
+ <keyword name="const_limit_reference< T_wrapped >::invoke" link="classsigc_1_1const__limit__reference.html#abb05a4234000dbf4a256b446d3ef580d" type="function"/>
+ <keyword name="const_limit_reference< T_wrapped >::visit" link="classsigc_1_1const__limit__reference.html#aa7486303566b2a9a74e55561083ed3d9" type="function"/>
+ <keyword type="struct" name="const_volatile_limit_reference< T_obj >" link="classsigc_1_1const__volatile__limit__reference.html"/>
+ <keyword name="const_volatile_limit_reference< T_obj >::const_volatile_limit_reference" link="classsigc_1_1const__volatile__limit__reference.html#a9a01809bae79cb1b13ee50ce9d84dcb8" type="function"/>
+ <keyword name="const_volatile_limit_reference< T_obj >::invoke" link="classsigc_1_1const__volatile__limit__reference.html#ac09d022e8991a946d49a714df8b2f1c7" type="function"/>
+ <keyword name="const_volatile_limit_reference< T_obj >::visit" link="classsigc_1_1const__volatile__limit__reference.html#a41c17ef86e8c65998ba42097c7ad5f09" type="function"/>
+ <keyword type="struct" name="limit_reference< T_obj >" link="classsigc_1_1limit__reference.html"/>
+ <keyword name="limit_reference< T_obj >::limit_reference" link="classsigc_1_1limit__reference.html#a58bf17e1eaa63d86336c831fa885bc66" type="function"/>
+ <keyword name="limit_reference< T_obj >::invoke" link="classsigc_1_1limit__reference.html#affd2902cd78ccdae45c499058c83e992" type="function"/>
+ <keyword name="limit_reference< T_obj >::visit" link="classsigc_1_1limit__reference.html#affeb3929fdc606c8fb7f8f29fa6fd12d" type="function"/>
+ <keyword type="struct" name="limit_reference< T_wrapped >" link="classsigc_1_1limit__reference.html"/>
+ <keyword name="limit_reference< T_wrapped >::limit_reference" link="classsigc_1_1limit__reference.html#a58bf17e1eaa63d86336c831fa885bc66" type="function"/>
+ <keyword name="limit_reference< T_wrapped >::invoke" link="classsigc_1_1limit__reference.html#affd2902cd78ccdae45c499058c83e992" type="function"/>
+ <keyword name="limit_reference< T_wrapped >::visit" link="classsigc_1_1limit__reference.html#affeb3929fdc606c8fb7f8f29fa6fd12d" type="function"/>
+ <keyword type="struct" name="sigc::adaptor_base" link="structsigc_1_1adaptor__base.html"/>
+ <keyword type="struct" name="sigc::adaptor_functor" link="structsigc_1_1adaptor__functor.html"/>
+ <keyword name="sigc::adaptor_functor::result_type" link="structsigc_1_1adaptor__functor.html#adc1e7ebba9db294494c62666e10b719b" type="typedef"/>
+ <keyword name="sigc::adaptor_functor::adaptor_functor" link="structsigc_1_1adaptor__functor.html#a39ef4610f8e0f03425b6f4a44b59e5fb" type="function"/>
+ <keyword name="sigc::adaptor_functor::adaptor_functor" link="structsigc_1_1adaptor__functor.html#ac5907212f7ee2eadf10b31757a0c5930" type="function"/>
+ <keyword name="sigc::adaptor_functor::adaptor_functor" link="structsigc_1_1adaptor__functor.html#af765e401002eb15f18aca5cfaa678b01" type="function"/>
+ <keyword name="sigc::adaptor_functor::operator()" link="structsigc_1_1adaptor__functor.html#aa8f3859324cce86596f0eb81b7bb6037" type="function"/>
+ <keyword name="sigc::adaptor_functor::operator()" link="structsigc_1_1adaptor__functor.html#ad5f69b862958bf7c45e7f6d3bc5f4c6e" type="function"/>
+ <keyword name="sigc::adaptor_functor::operator()" link="structsigc_1_1adaptor__functor.html#aab920cf1b05ce5d6c9513aa18323ea2a" type="function"/>
+ <keyword name="sigc::adaptor_functor::operator()" link="structsigc_1_1adaptor__functor.html#a0da9456dab8a22caffe6cfd624e32e30" type="function"/>
+ <keyword name="sigc::adaptor_functor::operator()" link="structsigc_1_1adaptor__functor.html#a2b393cd9388414a1a6ad7148eec4354a" type="function"/>
+ <keyword name="sigc::adaptor_functor::operator()" link="structsigc_1_1adaptor__functor.html#a9bec9cfe2f00505a35cdb2b8d5117b09" type="function"/>
+ <keyword name="sigc::adaptor_functor::operator()" link="structsigc_1_1adaptor__functor.html#a824de5f3164f45f78ea3771743b94ca4" type="function"/>
+ <keyword name="sigc::adaptor_functor::operator()" link="structsigc_1_1adaptor__functor.html#a5be4edc8ea900c6454cb024836b9f655" type="function"/>
+ <keyword type="struct" name="sigc::adaptor_trait" link="structsigc_1_1adaptor__trait.html"/>
+ <keyword type="struct" name="sigc::adaptor_trait< T_functor, false >" link="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html"/>
+ <keyword name="sigc::adaptor_trait< T_functor, false >::adaptor_type" link="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html#ad3bd68364a24b2b6580b523d5301b25c" type="typedef"/>
+ <keyword name="sigc::adaptor_trait< T_functor, false >::functor_type" link="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html#acb1a7066d665d00e2525c49d089efc0f" type="typedef"/>
+ <keyword name="sigc::adaptor_trait< T_functor, false >::result_type" link="structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html#a512a6d201bdd43574a2df993b3b85d0e" type="typedef"/>
+ <keyword type="struct" name="sigc::adaptor_trait< T_functor, true >" link="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html"/>
+ <keyword name="sigc::adaptor_trait< T_functor, true >::adaptor_type" link="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html#a449daad4cd77bd1fbfe59d8fae9d9039" type="typedef"/>
+ <keyword name="sigc::adaptor_trait< T_functor, true >::functor_type" link="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html#ae065e339af2abe58cad43d630328240f" type="typedef"/>
+ <keyword name="sigc::adaptor_trait< T_functor, true >::result_type" link="structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html#a6b83ed91f53a25e7002546a2835457b3" type="typedef"/>
+ <keyword type="struct" name="sigc::adapts" link="structsigc_1_1adapts.html"/>
+ <keyword name="sigc::adapts::adaptor_type" link="structsigc_1_1adapts.html#a5c3f3b614455552f4cd5d88b1f330248" type="typedef"/>
+ <keyword name="sigc::adapts::result_type" link="structsigc_1_1adapts.html#a914e75556dae1fdcf0162c4c99aca79d" type="typedef"/>
+ <keyword name="sigc::adapts::adapts" link="structsigc_1_1adapts.html#a947b69ccbdcabd4ef4163dcab96096f8" type="function"/>
+ <keyword type="struct" name="sigc::bind_functor" link="structsigc_1_1bind__functor.html"/>
+ <keyword type="struct" name="sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil >" link="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html"/>
+ <keyword name="sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil >::adaptor_type" link="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ac6004db92703257f83addd412037f1f7" type="typedef"/>
+ <keyword name="sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil >::result_type" link="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a1c6d091ffd70c23930cf6e2b9042d466" type="typedef"/>
+ <keyword name="sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil >::bind_functor" link="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ac170bca0fe2af4722cf6e1fd6b3de128" type="function"/>
+ <keyword name="sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil >::operator()" link="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a0f1c2891d52c9f564e571209dbef6f54" type="function"/>
+ <keyword name="sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil >::operator()" link="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#adf9d663d20ff816a2a4c7d8ffb567eb3" type="function"/>
+ <keyword name="sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil >::operator()" link="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a2f2685399ae595b5e51a3af8c2610481" type="function"/>
+ <keyword name="sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil >::operator()" link="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a711b443e433977b183c789b175865a1e" type="function"/>
+ <keyword name="sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil >::operator()" link="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a1d0808644eb398cf7036a446b853220d" type="function"/>
+ <keyword name="sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil >::operator()" link="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a8fb31d32467dfe99815ca39b766cafac" type="function"/>
+ <keyword name="sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil >::operator()" link="structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a40d96a28bc0a1b7d11e267cc1d7bc517" type="function"/>
+ <keyword type="struct" name="sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil >" link="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html"/>
+ <keyword name="sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil >::adaptor_type" link="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ac249b81b5d6fff6e7c4b1d9b47a98077" type="typedef"/>
+ <keyword name="sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil >::result_type" link="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#abd1e51093bf7d4428e443c2e6704bed9" type="typedef"/>
+ <keyword name="sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil >::bind_functor" link="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ad61bb64a42d144999a94767cd6031259" type="function"/>
+ <keyword name="sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil >::operator()" link="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a5bd5dd13ef2cd495cfd23b8d0f7cffbd" type="function"/>
+ <keyword name="sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil >::operator()" link="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a92e97561144280879cce1d04aa8fefa0" type="function"/>
+ <keyword name="sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil >::operator()" link="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a3bdae6371687d34e14925b732361f13f" type="function"/>
+ <keyword name="sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil >::operator()" link="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a768079067de0ad3fa076eef0bfa5da88" type="function"/>
+ <keyword name="sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil >::operator()" link="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a2f959146fe7ce94745de2b1d10f48a2e" type="function"/>
+ <keyword name="sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil >::operator()" link="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a636774490286342a00251061eb5c550d" type="function"/>
+ <keyword name="sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil >::operator()" link="structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a2774a9d3a219ad25326a6490aa4038ae" type="function"/>
+ <keyword type="struct" name="sigc::bind_return_functor" link="structsigc_1_1bind__return__functor.html"/>
+ <keyword name="sigc::bind_return_functor::result_type" link="structsigc_1_1bind__return__functor.html#a4fe6cb8d80573ae7abe934ba54879592" type="typedef"/>
+ <keyword name="sigc::bind_return_functor::bind_return_functor" link="structsigc_1_1bind__return__functor.html#a1fa9551283794b249cbbdf7d270745d4" type="function"/>
+ <keyword name="sigc::bind_return_functor::operator()" link="structsigc_1_1bind__return__functor.html#a35959a6f4d5f6ddc83f603ee67d25981" type="function"/>
+ <keyword name="sigc::bind_return_functor::operator()" link="structsigc_1_1bind__return__functor.html#aea28cfb0443ae04982fc47c9955303fe" type="function"/>
+ <keyword name="sigc::bind_return_functor::operator()" link="structsigc_1_1bind__return__functor.html#a0794dd9e28353fd8b9a7454b2621343e" type="function"/>
+ <keyword name="sigc::bind_return_functor::operator()" link="structsigc_1_1bind__return__functor.html#aa1fddb53a22007f28b4a79949ecd5d4c" type="function"/>
+ <keyword name="sigc::bind_return_functor::operator()" link="structsigc_1_1bind__return__functor.html#a82f9312afce202883c1f6431b3b6d1c6" type="function"/>
+ <keyword name="sigc::bind_return_functor::operator()" link="structsigc_1_1bind__return__functor.html#a87958210a6c240fd56e7386184b8da00" type="function"/>
+ <keyword name="sigc::bind_return_functor::operator()" link="structsigc_1_1bind__return__functor.html#a58f654259665ed6f02df042c5b00f888" type="function"/>
+ <keyword name="sigc::bind_return_functor::operator()" link="structsigc_1_1bind__return__functor.html#a1b9d2dc672b8dfd7c769bbcedf25d8aa" type="function"/>
+ <keyword type="struct" name="sigc::bound_argument" link="classsigc_1_1bound__argument.html"/>
+ <keyword name="sigc::bound_argument::bound_argument" link="classsigc_1_1bound__argument.html#a495bb69a41b38eda5d6ace5a36807a37" type="function"/>
+ <keyword name="sigc::bound_argument::invoke" link="classsigc_1_1bound__argument.html#af1cf20526bade89328a1ed398055bbba" type="function"/>
+ <keyword name="sigc::bound_argument::visit" link="classsigc_1_1bound__argument.html#ab29e53c5e983c45e4963e0ecace26465" type="function"/>
+ <keyword type="struct" name="sigc::bound_argument< const_reference_wrapper< T_wrapped > >" link="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html"/>
+ <keyword name="sigc::bound_argument< const_reference_wrapper< T_wrapped > >::bound_argument" link="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html#afdfab4386d34bd03e82b05a2eb1f2afe" type="function"/>
+ <keyword name="sigc::bound_argument< const_reference_wrapper< T_wrapped > >::invoke" link="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html#aa08b2efa73ad0a928f0be217da940671" type="function"/>
+ <keyword name="sigc::bound_argument< const_reference_wrapper< T_wrapped > >::visit" link="classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html#a11b6cda42100c2c463e50942c41ff9eb" type="function"/>
+ <keyword type="struct" name="sigc::bound_argument< reference_wrapper< T_wrapped > >" link="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html"/>
+ <keyword name="sigc::bound_argument< reference_wrapper< T_wrapped > >::bound_argument" link="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html#a46f705d774a2436055785b7a55830349" type="function"/>
+ <keyword name="sigc::bound_argument< reference_wrapper< T_wrapped > >::invoke" link="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html#adbeb73917559e0764bf367dfc6c4141d" type="function"/>
+ <keyword name="sigc::bound_argument< reference_wrapper< T_wrapped > >::visit" link="classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html#a5123890110dc1013071e68a615692ce3" type="function"/>
+ <keyword type="struct" name="sigc::bound_argument< std::reference_wrapper< T_wrapped > >" link="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html"/>
+ <keyword name="sigc::bound_argument< std::reference_wrapper< T_wrapped > >::bound_argument" link="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html#a597709183c9a0b753f4674aaab80b4ff" type="function"/>
+ <keyword name="sigc::bound_argument< std::reference_wrapper< T_wrapped > >::invoke" link="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html#a38950827998907494c25397f01552730" type="function"/>
+ <keyword name="sigc::bound_argument< std::reference_wrapper< T_wrapped > >::visit" link="classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html#a3d34b13540ac33e677024727ffd3a36e" type="function"/>
+ <keyword type="struct" name="sigc::bound_const_mem_functor0" link="classsigc_1_1bound__const__mem__functor0.html"/>
+ <keyword name="sigc::bound_const_mem_functor0::function_type" link="classsigc_1_1bound__const__mem__functor0.html#a12ae83ad7820bd716ed8a07484a339d9" type="typedef"/>
+ <keyword name="sigc::bound_const_mem_functor0::bound_const_mem_functor0" link="classsigc_1_1bound__const__mem__functor0.html#a44aeae8d1432f66fce9cd385094b78fa" type="function"/>
+ <keyword name="sigc::bound_const_mem_functor0::bound_const_mem_functor0" link="classsigc_1_1bound__const__mem__functor0.html#a67756fc7a32eb42309a1d55aea2eeb19" type="function"/>
+ <keyword name="sigc::bound_const_mem_functor0::operator()" link="classsigc_1_1bound__const__mem__functor0.html#a7949abb2e0a675ab7faccf4b0c2b5480" type="function"/>
+ <keyword type="struct" name="sigc::bound_const_mem_functor1" link="classsigc_1_1bound__const__mem__functor1.html"/>
+ <keyword name="sigc::bound_const_mem_functor1::function_type" link="classsigc_1_1bound__const__mem__functor1.html#a65f0cde178bdd7a26fe687a8748dac4e" type="typedef"/>
+ <keyword name="sigc::bound_const_mem_functor1::bound_const_mem_functor1" link="classsigc_1_1bound__const__mem__functor1.html#af62c239e5612df1b7c4c91a52a2e0c62" type="function"/>
+ <keyword name="sigc::bound_const_mem_functor1::bound_const_mem_functor1" link="classsigc_1_1bound__const__mem__functor1.html#aca80f40c27a3346521ffee81ba79da77" type="function"/>
+ <keyword name="sigc::bound_const_mem_functor1::operator()" link="classsigc_1_1bound__const__mem__functor1.html#a4ba51a05a053caf20d9306efb0f05791" type="function"/>
+ <keyword type="struct" name="sigc::bound_const_mem_functor2" link="classsigc_1_1bound__const__mem__functor2.html"/>
+ <keyword name="sigc::bound_const_mem_functor2::function_type" link="classsigc_1_1bound__const__mem__functor2.html#abe2916ee9b6867554b48370000eb6886" type="typedef"/>
+ <keyword name="sigc::bound_const_mem_functor2::bound_const_mem_functor2" link="classsigc_1_1bound__const__mem__functor2.html#ab5213783f248b53b357ea6385b7bbe7a" type="function"/>
+ <keyword name="sigc::bound_const_mem_functor2::bound_const_mem_functor2" link="classsigc_1_1bound__const__mem__functor2.html#a6732b8f5b308ff8ff1adea9e3734f4bf" type="function"/>
+ <keyword name="sigc::bound_const_mem_functor2::operator()" link="classsigc_1_1bound__const__mem__functor2.html#a00df32df2a5bafc0adb39da243ad3a3d" type="function"/>
+ <keyword type="struct" name="sigc::bound_const_mem_functor3" link="classsigc_1_1bound__const__mem__functor3.html"/>
+ <keyword name="sigc::bound_const_mem_functor3::function_type" link="classsigc_1_1bound__const__mem__functor3.html#ab4e793d8c65bf8754aea133a2473dc6c" type="typedef"/>
+ <keyword name="sigc::bound_const_mem_functor3::bound_const_mem_functor3" link="classsigc_1_1bound__const__mem__functor3.html#a7fa6101b1b387baac23a7861e2819ad9" type="function"/>
+ <keyword name="sigc::bound_const_mem_functor3::bound_const_mem_functor3" link="classsigc_1_1bound__const__mem__functor3.html#ae63bd158d8ce2571038d4f6382a7bc51" type="function"/>
+ <keyword name="sigc::bound_const_mem_functor3::operator()" link="classsigc_1_1bound__const__mem__functor3.html#aabad5390e5b2671de1b9fbba7bf1cda6" type="function"/>
+ <keyword type="struct" name="sigc::bound_const_mem_functor4" link="classsigc_1_1bound__const__mem__functor4.html"/>
+ <keyword name="sigc::bound_const_mem_functor4::function_type" link="classsigc_1_1bound__const__mem__functor4.html#a3ffc5790ded15878ce2704072791c4e9" type="typedef"/>
+ <keyword name="sigc::bound_const_mem_functor4::bound_const_mem_functor4" link="classsigc_1_1bound__const__mem__functor4.html#a06e43c95d6ace639ac169ff2d0083ebc" type="function"/>
+ <keyword name="sigc::bound_const_mem_functor4::bound_const_mem_functor4" link="classsigc_1_1bound__const__mem__functor4.html#a1d441ea8caf2d2ff8cfca414f259b657" type="function"/>
+ <keyword name="sigc::bound_const_mem_functor4::operator()" link="classsigc_1_1bound__const__mem__functor4.html#a4db87f79d355f2ca4f5ff20d47c35ee3" type="function"/>
+ <keyword type="struct" name="sigc::bound_const_mem_functor5" link="classsigc_1_1bound__const__mem__functor5.html"/>
+ <keyword name="sigc::bound_const_mem_functor5::function_type" link="classsigc_1_1bound__const__mem__functor5.html#a882a71b51f303ded9d1ce172b522692a" type="typedef"/>
+ <keyword name="sigc::bound_const_mem_functor5::bound_const_mem_functor5" link="classsigc_1_1bound__const__mem__functor5.html#a3c8a1d1411eea1136fa273886688290d" type="function"/>
+ <keyword name="sigc::bound_const_mem_functor5::bound_const_mem_functor5" link="classsigc_1_1bound__const__mem__functor5.html#a9e80ad7a6b586eb1d0cc0a4afc9ea1d4" type="function"/>
+ <keyword name="sigc::bound_const_mem_functor5::operator()" link="classsigc_1_1bound__const__mem__functor5.html#a89a861b0925989a0e845399443eee20a" type="function"/>
+ <keyword type="struct" name="sigc::bound_const_mem_functor6" link="classsigc_1_1bound__const__mem__functor6.html"/>
+ <keyword name="sigc::bound_const_mem_functor6::function_type" link="classsigc_1_1bound__const__mem__functor6.html#a9cd70f288cac9b8d7ee9695166f3d306" type="typedef"/>
+ <keyword name="sigc::bound_const_mem_functor6::bound_const_mem_functor6" link="classsigc_1_1bound__const__mem__functor6.html#afa0adf0adf9cde73008982d2494f3d7e" type="function"/>
+ <keyword name="sigc::bound_const_mem_functor6::bound_const_mem_functor6" link="classsigc_1_1bound__const__mem__functor6.html#a4c6a29813f84239bfc224e36d3ada58c" type="function"/>
+ <keyword name="sigc::bound_const_mem_functor6::operator()" link="classsigc_1_1bound__const__mem__functor6.html#a6bc7018118bbf55444f4d9250cf3ce65" type="function"/>
+ <keyword type="struct" name="sigc::bound_const_mem_functor7" link="classsigc_1_1bound__const__mem__functor7.html"/>
+ <keyword name="sigc::bound_const_mem_functor7::function_type" link="classsigc_1_1bound__const__mem__functor7.html#ae95db1c3ce4d07122e39dde2c9c5af02" type="typedef"/>
+ <keyword name="sigc::bound_const_mem_functor7::bound_const_mem_functor7" link="classsigc_1_1bound__const__mem__functor7.html#a22e365208dda5614599860d5794cb64f" type="function"/>
+ <keyword name="sigc::bound_const_mem_functor7::bound_const_mem_functor7" link="classsigc_1_1bound__const__mem__functor7.html#a3353dd997ced3fc00f44ee2b8ccb0063" type="function"/>
+ <keyword name="sigc::bound_const_mem_functor7::operator()" link="classsigc_1_1bound__const__mem__functor7.html#a941b925ad1f628cde49bb268be8daf4a" type="function"/>
+ <keyword type="struct" name="sigc::bound_const_volatile_mem_functor0" link="classsigc_1_1bound__const__volatile__mem__functor0.html"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor0::function_type" link="classsigc_1_1bound__const__volatile__mem__functor0.html#a622322ff2ef93f0e611fd6f93f6ccdcc" type="typedef"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor0::bound_const_volatile_mem_functor0" link="classsigc_1_1bound__const__volatile__mem__functor0.html#a12e99e7dc91602d1e7170a791f96a616" type="function"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor0::bound_const_volatile_mem_functor0" link="classsigc_1_1bound__const__volatile__mem__functor0.html#a364e1b19994e41acf1d99d27ffca8924" type="function"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor0::operator()" link="classsigc_1_1bound__const__volatile__mem__functor0.html#abbe8bbaa0d3d7318046be146fe6fda03" type="function"/>
+ <keyword type="struct" name="sigc::bound_const_volatile_mem_functor1" link="classsigc_1_1bound__const__volatile__mem__functor1.html"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor1::function_type" link="classsigc_1_1bound__const__volatile__mem__functor1.html#ac7a0c09914219d8baf1715675e838e59" type="typedef"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor1::bound_const_volatile_mem_functor1" link="classsigc_1_1bound__const__volatile__mem__functor1.html#aaccca7de16e3da31976680b714d10e79" type="function"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor1::bound_const_volatile_mem_functor1" link="classsigc_1_1bound__const__volatile__mem__functor1.html#ac99241e0e7ba52e295f6176c03cdd741" type="function"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor1::operator()" link="classsigc_1_1bound__const__volatile__mem__functor1.html#a0c520be9f25daa56ca9aba061edb7e77" type="function"/>
+ <keyword type="struct" name="sigc::bound_const_volatile_mem_functor2" link="classsigc_1_1bound__const__volatile__mem__functor2.html"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor2::function_type" link="classsigc_1_1bound__const__volatile__mem__functor2.html#a26e4bc5d2c64c1029b760fe7994fee3f" type="typedef"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor2::bound_const_volatile_mem_functor2" link="classsigc_1_1bound__const__volatile__mem__functor2.html#a6a7a540b5e6a5e7d322a448904bc8881" type="function"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor2::bound_const_volatile_mem_functor2" link="classsigc_1_1bound__const__volatile__mem__functor2.html#a1b629cd2ff30fcaeb035136e190c3f4d" type="function"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor2::operator()" link="classsigc_1_1bound__const__volatile__mem__functor2.html#a434acb850963a28b1a5a4662fad2b5d5" type="function"/>
+ <keyword type="struct" name="sigc::bound_const_volatile_mem_functor3" link="classsigc_1_1bound__const__volatile__mem__functor3.html"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor3::function_type" link="classsigc_1_1bound__const__volatile__mem__functor3.html#ae127200c20b69f91ccaf40eb60f2c448" type="typedef"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor3::bound_const_volatile_mem_functor3" link="classsigc_1_1bound__const__volatile__mem__functor3.html#a3fbbc6533b408ccde3d517b1f2a38223" type="function"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor3::bound_const_volatile_mem_functor3" link="classsigc_1_1bound__const__volatile__mem__functor3.html#a7c5661cbb3554624e50c62789f339aaf" type="function"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor3::operator()" link="classsigc_1_1bound__const__volatile__mem__functor3.html#af14d93c72657777d2257e3db60f20a01" type="function"/>
+ <keyword type="struct" name="sigc::bound_const_volatile_mem_functor4" link="classsigc_1_1bound__const__volatile__mem__functor4.html"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor4::function_type" link="classsigc_1_1bound__const__volatile__mem__functor4.html#a2c06c731ae9564be215802a98541d06c" type="typedef"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor4::bound_const_volatile_mem_functor4" link="classsigc_1_1bound__const__volatile__mem__functor4.html#a4e0fdda617113a58f8839ab53a9fa613" type="function"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor4::bound_const_volatile_mem_functor4" link="classsigc_1_1bound__const__volatile__mem__functor4.html#a97b15b931ba6db1852011d252dd3d5f0" type="function"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor4::operator()" link="classsigc_1_1bound__const__volatile__mem__functor4.html#ac1593becd15c2704535c9b50482503f9" type="function"/>
+ <keyword type="struct" name="sigc::bound_const_volatile_mem_functor5" link="classsigc_1_1bound__const__volatile__mem__functor5.html"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor5::function_type" link="classsigc_1_1bound__const__volatile__mem__functor5.html#a54debcbe3edf1a9606aad9cfcc1e004c" type="typedef"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor5::bound_const_volatile_mem_functor5" link="classsigc_1_1bound__const__volatile__mem__functor5.html#a178805b13affaa2b0fbaafe287cb9390" type="function"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor5::bound_const_volatile_mem_functor5" link="classsigc_1_1bound__const__volatile__mem__functor5.html#acc05a40bf47bd943c5d822b354a80ae9" type="function"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor5::operator()" link="classsigc_1_1bound__const__volatile__mem__functor5.html#a7f70def3a438e6735b67f669c8fc107a" type="function"/>
+ <keyword type="struct" name="sigc::bound_const_volatile_mem_functor6" link="classsigc_1_1bound__const__volatile__mem__functor6.html"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor6::function_type" link="classsigc_1_1bound__const__volatile__mem__functor6.html#aa8d75053aa097f0632c13bf1185f84a9" type="typedef"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor6::bound_const_volatile_mem_functor6" link="classsigc_1_1bound__const__volatile__mem__functor6.html#ac5aa6dc8967fed463dd69f412ded1fd1" type="function"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor6::bound_const_volatile_mem_functor6" link="classsigc_1_1bound__const__volatile__mem__functor6.html#ae07e825b1d3ee4fa7d4dd45eb7f2fbad" type="function"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor6::operator()" link="classsigc_1_1bound__const__volatile__mem__functor6.html#a9cd3a5dd70008fe70d17712cfee0f470" type="function"/>
+ <keyword type="struct" name="sigc::bound_const_volatile_mem_functor7" link="classsigc_1_1bound__const__volatile__mem__functor7.html"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor7::function_type" link="classsigc_1_1bound__const__volatile__mem__functor7.html#a48030a47276e3eede338fc78c79e5a35" type="typedef"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor7::bound_const_volatile_mem_functor7" link="classsigc_1_1bound__const__volatile__mem__functor7.html#aed3adf188de8b282a4a597fb5e4a07bc" type="function"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor7::bound_const_volatile_mem_functor7" link="classsigc_1_1bound__const__volatile__mem__functor7.html#a6f2635a9548c06f2f5090d75df09fbf1" type="function"/>
+ <keyword name="sigc::bound_const_volatile_mem_functor7::operator()" link="classsigc_1_1bound__const__volatile__mem__functor7.html#a8fe1055d39082226d8acb3201b7b5ce7" type="function"/>
+ <keyword type="struct" name="sigc::bound_mem_functor0" link="classsigc_1_1bound__mem__functor0.html"/>
+ <keyword name="sigc::bound_mem_functor0::function_type" link="classsigc_1_1bound__mem__functor0.html#a36b5479bfc091c063d44b11ad024393a" type="typedef"/>
+ <keyword name="sigc::bound_mem_functor0::bound_mem_functor0" link="classsigc_1_1bound__mem__functor0.html#a137ab7d3b66b421f664e154e3d01e66c" type="function"/>
+ <keyword name="sigc::bound_mem_functor0::bound_mem_functor0" link="classsigc_1_1bound__mem__functor0.html#a7de90a27f55055cae43df1425cc78415" type="function"/>
+ <keyword name="sigc::bound_mem_functor0::operator()" link="classsigc_1_1bound__mem__functor0.html#a8f0ea7caa1c5858b44ebdb0bcf4ba74a" type="function"/>
+ <keyword type="struct" name="sigc::bound_mem_functor1" link="classsigc_1_1bound__mem__functor1.html"/>
+ <keyword name="sigc::bound_mem_functor1::function_type" link="classsigc_1_1bound__mem__functor1.html#a8e460c2a0eb87dcaf263c984b4dc5888" type="typedef"/>
+ <keyword name="sigc::bound_mem_functor1::bound_mem_functor1" link="classsigc_1_1bound__mem__functor1.html#a777afe4673c9adc0798a38fc96bca7f6" type="function"/>
+ <keyword name="sigc::bound_mem_functor1::bound_mem_functor1" link="classsigc_1_1bound__mem__functor1.html#ad13235c20a9171bd24a4f8ae36577448" type="function"/>
+ <keyword name="sigc::bound_mem_functor1::operator()" link="classsigc_1_1bound__mem__functor1.html#af9d43a802f122d38d264b3f662bcfe43" type="function"/>
+ <keyword type="struct" name="sigc::bound_mem_functor2" link="classsigc_1_1bound__mem__functor2.html"/>
+ <keyword name="sigc::bound_mem_functor2::function_type" link="classsigc_1_1bound__mem__functor2.html#a1b0b5d2145f50d19214ff41bd45ab978" type="typedef"/>
+ <keyword name="sigc::bound_mem_functor2::bound_mem_functor2" link="classsigc_1_1bound__mem__functor2.html#a830746b33cae370b756334e4a8cab703" type="function"/>
+ <keyword name="sigc::bound_mem_functor2::bound_mem_functor2" link="classsigc_1_1bound__mem__functor2.html#a48bc9b34469749461813061d17680ca2" type="function"/>
+ <keyword name="sigc::bound_mem_functor2::operator()" link="classsigc_1_1bound__mem__functor2.html#a09d48d61cc092e3f12c8ac4df4449596" type="function"/>
+ <keyword type="struct" name="sigc::bound_mem_functor3" link="classsigc_1_1bound__mem__functor3.html"/>
+ <keyword name="sigc::bound_mem_functor3::function_type" link="classsigc_1_1bound__mem__functor3.html#a66d1aa7ad3edafd8851ee0b334f83efe" type="typedef"/>
+ <keyword name="sigc::bound_mem_functor3::bound_mem_functor3" link="classsigc_1_1bound__mem__functor3.html#a1d1dddd6a334864611f5dc3a8ece26f9" type="function"/>
+ <keyword name="sigc::bound_mem_functor3::bound_mem_functor3" link="classsigc_1_1bound__mem__functor3.html#aadbbb586e3ba0c44a25c1f3834c4c438" type="function"/>
+ <keyword name="sigc::bound_mem_functor3::operator()" link="classsigc_1_1bound__mem__functor3.html#aa61ed1a1c920069032ffd5427d24a771" type="function"/>
+ <keyword type="struct" name="sigc::bound_mem_functor4" link="classsigc_1_1bound__mem__functor4.html"/>
+ <keyword name="sigc::bound_mem_functor4::function_type" link="classsigc_1_1bound__mem__functor4.html#aeddcfc0ce5fe38259608bfc88af37568" type="typedef"/>
+ <keyword name="sigc::bound_mem_functor4::bound_mem_functor4" link="classsigc_1_1bound__mem__functor4.html#ae15ccaa9f58865b2cd9929644aa85612" type="function"/>
+ <keyword name="sigc::bound_mem_functor4::bound_mem_functor4" link="classsigc_1_1bound__mem__functor4.html#a15b592122574775dd2c4804617e1e3dd" type="function"/>
+ <keyword name="sigc::bound_mem_functor4::operator()" link="classsigc_1_1bound__mem__functor4.html#a0a9d2fb52ef15ae8d4e56238217c0539" type="function"/>
+ <keyword type="struct" name="sigc::bound_mem_functor5" link="classsigc_1_1bound__mem__functor5.html"/>
+ <keyword name="sigc::bound_mem_functor5::function_type" link="classsigc_1_1bound__mem__functor5.html#a91181f20bd393befce307655486949ad" type="typedef"/>
+ <keyword name="sigc::bound_mem_functor5::bound_mem_functor5" link="classsigc_1_1bound__mem__functor5.html#a179304173879dac0023d49e313125c8c" type="function"/>
+ <keyword name="sigc::bound_mem_functor5::bound_mem_functor5" link="classsigc_1_1bound__mem__functor5.html#aaf05ba83268cf4a55f96db281898b406" type="function"/>
+ <keyword name="sigc::bound_mem_functor5::operator()" link="classsigc_1_1bound__mem__functor5.html#aa1de6366cd9e5f0ea037287438a8072f" type="function"/>
+ <keyword type="struct" name="sigc::bound_mem_functor6" link="classsigc_1_1bound__mem__functor6.html"/>
+ <keyword name="sigc::bound_mem_functor6::function_type" link="classsigc_1_1bound__mem__functor6.html#ac92e6b87056623eeec0d09a35f41296d" type="typedef"/>
+ <keyword name="sigc::bound_mem_functor6::bound_mem_functor6" link="classsigc_1_1bound__mem__functor6.html#abff60fd63e92b1c28c2aacf1cee93508" type="function"/>
+ <keyword name="sigc::bound_mem_functor6::bound_mem_functor6" link="classsigc_1_1bound__mem__functor6.html#ab2724a290ceef4f2c279156b606e8c88" type="function"/>
+ <keyword name="sigc::bound_mem_functor6::operator()" link="classsigc_1_1bound__mem__functor6.html#ad44376814c73959398026d4e0df3d401" type="function"/>
+ <keyword type="struct" name="sigc::bound_mem_functor7" link="classsigc_1_1bound__mem__functor7.html"/>
+ <keyword name="sigc::bound_mem_functor7::function_type" link="classsigc_1_1bound__mem__functor7.html#a0fcd4636185a806d055d6b885503863b" type="typedef"/>
+ <keyword name="sigc::bound_mem_functor7::bound_mem_functor7" link="classsigc_1_1bound__mem__functor7.html#a29f43e3ad8d4714c8f3477be02d62c3d" type="function"/>
+ <keyword name="sigc::bound_mem_functor7::bound_mem_functor7" link="classsigc_1_1bound__mem__functor7.html#a989011ff72d908959d2f0ad346357706" type="function"/>
+ <keyword name="sigc::bound_mem_functor7::operator()" link="classsigc_1_1bound__mem__functor7.html#ab0c379b445a5655f55f8260c699e7053" type="function"/>
+ <keyword type="struct" name="sigc::bound_volatile_mem_functor0" link="classsigc_1_1bound__volatile__mem__functor0.html"/>
+ <keyword name="sigc::bound_volatile_mem_functor0::function_type" link="classsigc_1_1bound__volatile__mem__functor0.html#a9a07aa91b2bd5ef0c4fc1a89bad5d3b0" type="typedef"/>
+ <keyword name="sigc::bound_volatile_mem_functor0::bound_volatile_mem_functor0" link="classsigc_1_1bound__volatile__mem__functor0.html#a4f81dd585b0aae830cd585ebb5867e20" type="function"/>
+ <keyword name="sigc::bound_volatile_mem_functor0::bound_volatile_mem_functor0" link="classsigc_1_1bound__volatile__mem__functor0.html#a5812d3638dc20b9fe37688d31dde8ed8" type="function"/>
+ <keyword name="sigc::bound_volatile_mem_functor0::operator()" link="classsigc_1_1bound__volatile__mem__functor0.html#a5726bcc0d34cff2356976bc586d36b44" type="function"/>
+ <keyword type="struct" name="sigc::bound_volatile_mem_functor1" link="classsigc_1_1bound__volatile__mem__functor1.html"/>
+ <keyword name="sigc::bound_volatile_mem_functor1::function_type" link="classsigc_1_1bound__volatile__mem__functor1.html#a38ee12aba5c1d6a7c608165a1137219a" type="typedef"/>
+ <keyword name="sigc::bound_volatile_mem_functor1::bound_volatile_mem_functor1" link="classsigc_1_1bound__volatile__mem__functor1.html#ae51c0fe21853f42cd9890f5f995f4d87" type="function"/>
+ <keyword name="sigc::bound_volatile_mem_functor1::bound_volatile_mem_functor1" link="classsigc_1_1bound__volatile__mem__functor1.html#af0b1a108c0080fe202b1d77cae86a7d0" type="function"/>
+ <keyword name="sigc::bound_volatile_mem_functor1::operator()" link="classsigc_1_1bound__volatile__mem__functor1.html#a989556175b19d8e13c34727f231228ad" type="function"/>
+ <keyword type="struct" name="sigc::bound_volatile_mem_functor2" link="classsigc_1_1bound__volatile__mem__functor2.html"/>
+ <keyword name="sigc::bound_volatile_mem_functor2::function_type" link="classsigc_1_1bound__volatile__mem__functor2.html#a16d5240b9bbb31ae266725d20b0f37d7" type="typedef"/>
+ <keyword name="sigc::bound_volatile_mem_functor2::bound_volatile_mem_functor2" link="classsigc_1_1bound__volatile__mem__functor2.html#ac3a72dc9eb316e9f096cb0a93792e368" type="function"/>
+ <keyword name="sigc::bound_volatile_mem_functor2::bound_volatile_mem_functor2" link="classsigc_1_1bound__volatile__mem__functor2.html#af2222c46ab0b47bd59af92ad509ef6fb" type="function"/>
+ <keyword name="sigc::bound_volatile_mem_functor2::operator()" link="classsigc_1_1bound__volatile__mem__functor2.html#a5a93614f492dacd37dd1cfd94cc033b3" type="function"/>
+ <keyword type="struct" name="sigc::bound_volatile_mem_functor3" link="classsigc_1_1bound__volatile__mem__functor3.html"/>
+ <keyword name="sigc::bound_volatile_mem_functor3::function_type" link="classsigc_1_1bound__volatile__mem__functor3.html#abc967931a7ab1411e02c022035073be5" type="typedef"/>
+ <keyword name="sigc::bound_volatile_mem_functor3::bound_volatile_mem_functor3" link="classsigc_1_1bound__volatile__mem__functor3.html#a1f2aacad170885008a58975c8562a863" type="function"/>
+ <keyword name="sigc::bound_volatile_mem_functor3::bound_volatile_mem_functor3" link="classsigc_1_1bound__volatile__mem__functor3.html#a21c0be5f093ddcd084cc5ad172ceaf92" type="function"/>
+ <keyword name="sigc::bound_volatile_mem_functor3::operator()" link="classsigc_1_1bound__volatile__mem__functor3.html#af5b4934a8e75fd7c32d41a989ec67f66" type="function"/>
+ <keyword type="struct" name="sigc::bound_volatile_mem_functor4" link="classsigc_1_1bound__volatile__mem__functor4.html"/>
+ <keyword name="sigc::bound_volatile_mem_functor4::function_type" link="classsigc_1_1bound__volatile__mem__functor4.html#a7a30b6a2e3067254fdea50104fea8469" type="typedef"/>
+ <keyword name="sigc::bound_volatile_mem_functor4::bound_volatile_mem_functor4" link="classsigc_1_1bound__volatile__mem__functor4.html#a7264500594318b92a0a668fcfbbeffbc" type="function"/>
+ <keyword name="sigc::bound_volatile_mem_functor4::bound_volatile_mem_functor4" link="classsigc_1_1bound__volatile__mem__functor4.html#ae2385ee536e72cfbb0d945ba770f2e69" type="function"/>
+ <keyword name="sigc::bound_volatile_mem_functor4::operator()" link="classsigc_1_1bound__volatile__mem__functor4.html#a22702ad82b54c77d93fb6d0481896d8f" type="function"/>
+ <keyword type="struct" name="sigc::bound_volatile_mem_functor5" link="classsigc_1_1bound__volatile__mem__functor5.html"/>
+ <keyword name="sigc::bound_volatile_mem_functor5::function_type" link="classsigc_1_1bound__volatile__mem__functor5.html#a1561f499bd4d950fd36ee43ee60db585" type="typedef"/>
+ <keyword name="sigc::bound_volatile_mem_functor5::bound_volatile_mem_functor5" link="classsigc_1_1bound__volatile__mem__functor5.html#a01734765e6a89bd0ab89063f130541e3" type="function"/>
+ <keyword name="sigc::bound_volatile_mem_functor5::bound_volatile_mem_functor5" link="classsigc_1_1bound__volatile__mem__functor5.html#af5e4db24b5ba51d92746aa3fee080d49" type="function"/>
+ <keyword name="sigc::bound_volatile_mem_functor5::operator()" link="classsigc_1_1bound__volatile__mem__functor5.html#aaf0765f195ee2efef0536dfb854af9e4" type="function"/>
+ <keyword type="struct" name="sigc::bound_volatile_mem_functor6" link="classsigc_1_1bound__volatile__mem__functor6.html"/>
+ <keyword name="sigc::bound_volatile_mem_functor6::function_type" link="classsigc_1_1bound__volatile__mem__functor6.html#a6eeca5f695bff3c3302e4cf7d222a73d" type="typedef"/>
+ <keyword name="sigc::bound_volatile_mem_functor6::bound_volatile_mem_functor6" link="classsigc_1_1bound__volatile__mem__functor6.html#af79be68e9cb6c772f6d6e817bffe9656" type="function"/>
+ <keyword name="sigc::bound_volatile_mem_functor6::bound_volatile_mem_functor6" link="classsigc_1_1bound__volatile__mem__functor6.html#acb8a7befd300496343cf46d8520db04f" type="function"/>
+ <keyword name="sigc::bound_volatile_mem_functor6::operator()" link="classsigc_1_1bound__volatile__mem__functor6.html#aa8aa3006bba7344c630f6f8adb3507d5" type="function"/>
+ <keyword type="struct" name="sigc::bound_volatile_mem_functor7" link="classsigc_1_1bound__volatile__mem__functor7.html"/>
+ <keyword name="sigc::bound_volatile_mem_functor7::function_type" link="classsigc_1_1bound__volatile__mem__functor7.html#afce6246f9f2828a7185b3c696435d70a" type="typedef"/>
+ <keyword name="sigc::bound_volatile_mem_functor7::bound_volatile_mem_functor7" link="classsigc_1_1bound__volatile__mem__functor7.html#a3109683023c9e82a586660399b12769e" type="function"/>
+ <keyword name="sigc::bound_volatile_mem_functor7::bound_volatile_mem_functor7" link="classsigc_1_1bound__volatile__mem__functor7.html#a18f28191685aa86228328e7016b5c803" type="function"/>
+ <keyword name="sigc::bound_volatile_mem_functor7::operator()" link="classsigc_1_1bound__volatile__mem__functor7.html#ad1ab1d5cf45600c5369a0a119a5a89ad" type="function"/>
+ <keyword type="struct" name="sigc::can_deduce_result_type_with_decltype" link="classsigc_1_1can__deduce__result__type__with__decltype.html"/>
+ <keyword type="struct" name="sigc::compose1_functor" link="structsigc_1_1compose1__functor.html"/>
+ <keyword name="sigc::compose1_functor::adaptor_type" link="structsigc_1_1compose1__functor.html#a90d506f177dca8afeaef61b6b5956541" type="typedef"/>
+ <keyword name="sigc::compose1_functor::getter_type" link="structsigc_1_1compose1__functor.html#ad54c2d62658fb7a47da41df0ccfc618c" type="typedef"/>
+ <keyword name="sigc::compose1_functor::result_type" link="structsigc_1_1compose1__functor.html#ab096c0a388f877d97b3812f2fcc813f9" type="typedef"/>
+ <keyword name="sigc::compose1_functor::setter_type" link="structsigc_1_1compose1__functor.html#a86a8bc8f4926f7bb91ef362fff03a25e" type="typedef"/>
+ <keyword name="sigc::compose1_functor::compose1_functor" link="structsigc_1_1compose1__functor.html#a1bb831ebfb46a214a6ffda98e77ad044" type="function"/>
+ <keyword name="sigc::compose1_functor::operator()" link="structsigc_1_1compose1__functor.html#ae7c074e7656595157b0f421028e34609" type="function"/>
+ <keyword name="sigc::compose1_functor::operator()" link="structsigc_1_1compose1__functor.html#ab32178c24587037b5ae30b8b807f5a35" type="function"/>
+ <keyword name="sigc::compose1_functor::operator()" link="structsigc_1_1compose1__functor.html#afff816d0f3e6959be7c5f268559f3e2f" type="function"/>
+ <keyword name="sigc::compose1_functor::operator()" link="structsigc_1_1compose1__functor.html#aa53fd7a2a0b51d8c0c0e4568559292b7" type="function"/>
+ <keyword name="sigc::compose1_functor::operator()" link="structsigc_1_1compose1__functor.html#a4bc76b086fdcf3f823b055b9d6e76dab" type="function"/>
+ <keyword name="sigc::compose1_functor::operator()" link="structsigc_1_1compose1__functor.html#aebb21782ac3e60c4f817de69a316a711" type="function"/>
+ <keyword name="sigc::compose1_functor::operator()" link="structsigc_1_1compose1__functor.html#a70de905fa8c830cecf3526704c4290de" type="function"/>
+ <keyword name="sigc::compose1_functor::operator()" link="structsigc_1_1compose1__functor.html#afe1dd6cb126a8c401355b7b1c189a5d9" type="function"/>
+ <keyword type="struct" name="sigc::compose2_functor" link="structsigc_1_1compose2__functor.html"/>
+ <keyword name="sigc::compose2_functor::adaptor_type" link="structsigc_1_1compose2__functor.html#ac1c9b3dc43cc75ec65fe0708fb4450d8" type="typedef"/>
+ <keyword name="sigc::compose2_functor::getter1_type" link="structsigc_1_1compose2__functor.html#ab7ab82eee45e8df9116a5a2b7c12c39c" type="typedef"/>
+ <keyword name="sigc::compose2_functor::getter2_type" link="structsigc_1_1compose2__functor.html#a75e252684d06f75f036043df56d8df69" type="typedef"/>
+ <keyword name="sigc::compose2_functor::result_type" link="structsigc_1_1compose2__functor.html#a78ccb07f23696a452df9f61308885542" type="typedef"/>
+ <keyword name="sigc::compose2_functor::setter_type" link="structsigc_1_1compose2__functor.html#ac3d7308c702df7378af1635281d5f7b8" type="typedef"/>
+ <keyword name="sigc::compose2_functor::compose2_functor" link="structsigc_1_1compose2__functor.html#a72719db97ab3ffdc0176ea3b443ffb60" type="function"/>
+ <keyword name="sigc::compose2_functor::operator()" link="structsigc_1_1compose2__functor.html#a3cfcfa7d8d95962b3448ed886f3495a0" type="function"/>
+ <keyword name="sigc::compose2_functor::operator()" link="structsigc_1_1compose2__functor.html#adfcd11f81cefb39743d9467d21510c53" type="function"/>
+ <keyword name="sigc::compose2_functor::operator()" link="structsigc_1_1compose2__functor.html#a048e0ff176de0813c190279afd7e16dd" type="function"/>
+ <keyword name="sigc::compose2_functor::operator()" link="structsigc_1_1compose2__functor.html#a48c102ded15a30326d7daefa8b817dd3" type="function"/>
+ <keyword name="sigc::compose2_functor::operator()" link="structsigc_1_1compose2__functor.html#aaa7e4c7aae30b0585039655a71ed6850" type="function"/>
+ <keyword name="sigc::compose2_functor::operator()" link="structsigc_1_1compose2__functor.html#acb668cbfa312852668695eda2198c64b" type="function"/>
+ <keyword name="sigc::compose2_functor::operator()" link="structsigc_1_1compose2__functor.html#af0cfb941c315a47381eaa288bfd87428" type="function"/>
+ <keyword name="sigc::compose2_functor::operator()" link="structsigc_1_1compose2__functor.html#af39ab33c42d6e7c715b9f5e8ba4eb556" type="function"/>
+ <keyword type="struct" name="sigc::connection" link="structsigc_1_1connection.html"/>
+ <keyword name="sigc::connection::connection" link="structsigc_1_1connection.html#a95f80dbbf10fde0b851d78ec12cc2629" type="function"/>
+ <keyword name="sigc::connection::connection" link="structsigc_1_1connection.html#ad13d5e3331cc9b1494e0edb8fa37fdba" type="function"/>
+ <keyword name="sigc::connection::connection" link="structsigc_1_1connection.html#ac8847ae94e0b05bed6c81f54f58deef3" type="function"/>
+ <keyword name="sigc::connection::connection" link="structsigc_1_1connection.html#a124709de26781e5ffcf8bbb5dcd621ed" type="function"/>
+ <keyword name="sigc::connection::~connection" link="structsigc_1_1connection.html#a99678ccb2be5c20719f37e469416578a" type="function"/>
+ <keyword name="sigc::connection::block" link="structsigc_1_1connection.html#a581ae4f2b708cb6be7b081557864d6ec" type="function"/>
+ <keyword name="sigc::connection::blocked" link="structsigc_1_1connection.html#a7c86964aa4b0f339db5842e6c7e604f3" type="function"/>
+ <keyword name="sigc::connection::connected" link="structsigc_1_1connection.html#a307b5df56439539be66f92d6e39f0bce" type="function"/>
+ <keyword name="sigc::connection::disconnect" link="structsigc_1_1connection.html#a0452bd182a61650d14a9664d6297ed1b" type="function"/>
+ <keyword name="sigc::connection::empty" link="structsigc_1_1connection.html#a810bdde9fbe7ad10bf9d578eebf929de" type="function"/>
+ <keyword name="sigc::connection::operator bool" link="structsigc_1_1connection.html#a93215e1ea86c5fd0a465b2c4dba1257e" type="function"/>
+ <keyword name="sigc::connection::operator=" link="structsigc_1_1connection.html#a016094b53bafdc9ce593febb68cb00a5" type="function"/>
+ <keyword name="sigc::connection::operator=" link="structsigc_1_1connection.html#adee4ffd4b1669b4726fd9afc36330c14" type="function"/>
+ <keyword name="sigc::connection::unblock" link="structsigc_1_1connection.html#a15abcbfa76f1e5d8601cf4ad4176ed50" type="function"/>
+ <keyword name="sigc::connection::notify" link="structsigc_1_1connection.html#ad45fe90d68fe295e76e130b070e97070" type="function"/>
+ <keyword type="struct" name="sigc::const_limit_reference" link="classsigc_1_1const__limit__reference.html"/>
+ <keyword name="sigc::const_limit_reference::const_limit_reference" link="classsigc_1_1const__limit__reference.html#acee8a4c09720730cd5f66696fd018b4c" type="function"/>
+ <keyword name="sigc::const_limit_reference::invoke" link="classsigc_1_1const__limit__reference.html#abb05a4234000dbf4a256b446d3ef580d" type="function"/>
+ <keyword name="sigc::const_limit_reference::visit" link="classsigc_1_1const__limit__reference.html#aa7486303566b2a9a74e55561083ed3d9" type="function"/>
+ <keyword type="struct" name="sigc::const_limit_reference< T_type, true >" link="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html"/>
+ <keyword name="sigc::const_limit_reference< T_type, true >::const_limit_reference" link="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html#a68f1337800c19036c81512e76e0dd6cd" type="function"/>
+ <keyword name="sigc::const_limit_reference< T_type, true >::invoke" link="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html#a694136bfdbcc64717181ea2cc4714fa3" type="function"/>
+ <keyword name="sigc::const_limit_reference< T_type, true >::visit" link="classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html#abe87b8e67b8a26658a5d6f45b036721a" type="function"/>
+ <keyword type="struct" name="sigc::const_mem_functor0" link="classsigc_1_1const__mem__functor0.html"/>
+ <keyword name="sigc::const_mem_functor0::function_type" link="classsigc_1_1const__mem__functor0.html#a5b768319ee81e2aa9e96a900e5e64996" type="typedef"/>
+ <keyword name="sigc::const_mem_functor0::result_type" link="classsigc_1_1const__mem__functor0.html#a553cd4d85524b5deea445b67773527bf" type="typedef"/>
+ <keyword name="sigc::const_mem_functor0::const_mem_functor0" link="classsigc_1_1const__mem__functor0.html#a49bba4c8045b8b6933b8f5a854ac98d6" type="function"/>
+ <keyword name="sigc::const_mem_functor0::const_mem_functor0" link="classsigc_1_1const__mem__functor0.html#a27895e58972642453f7b853f25a66f42" type="function"/>
+ <keyword name="sigc::const_mem_functor0::operator()" link="classsigc_1_1const__mem__functor0.html#ac388853f99f074e549c8784d1a38f46b" type="function"/>
+ <keyword name="sigc::const_mem_functor0::operator()" link="classsigc_1_1const__mem__functor0.html#abcc08c39943577648dac107692e5b34a" type="function"/>
+ <keyword type="struct" name="sigc::const_mem_functor1" link="classsigc_1_1const__mem__functor1.html"/>
+ <keyword name="sigc::const_mem_functor1::function_type" link="classsigc_1_1const__mem__functor1.html#a14e585a05b63c5e4790b3de75cb18c96" type="typedef"/>
+ <keyword name="sigc::const_mem_functor1::result_type" link="classsigc_1_1const__mem__functor1.html#a8ba6a6565b8a29812e266aa4e5261a2d" type="typedef"/>
+ <keyword name="sigc::const_mem_functor1::const_mem_functor1" link="classsigc_1_1const__mem__functor1.html#a2c171737e0c7dc6ae00f73f1580a976d" type="function"/>
+ <keyword name="sigc::const_mem_functor1::const_mem_functor1" link="classsigc_1_1const__mem__functor1.html#aba30421222bd496f9dec9b733fe70447" type="function"/>
+ <keyword name="sigc::const_mem_functor1::operator()" link="classsigc_1_1const__mem__functor1.html#a3a575262ae2d62c39c52280017956a95" type="function"/>
+ <keyword name="sigc::const_mem_functor1::operator()" link="classsigc_1_1const__mem__functor1.html#a9e549ccae24d5a7d1741f17c09db7d5f" type="function"/>
+ <keyword type="struct" name="sigc::const_mem_functor2" link="classsigc_1_1const__mem__functor2.html"/>
+ <keyword name="sigc::const_mem_functor2::function_type" link="classsigc_1_1const__mem__functor2.html#a2294d014482fee6845b69ab5bc27daa9" type="typedef"/>
+ <keyword name="sigc::const_mem_functor2::result_type" link="classsigc_1_1const__mem__functor2.html#a5eaa5f2ab10ad755c89ff5b09c1e281d" type="typedef"/>
+ <keyword name="sigc::const_mem_functor2::const_mem_functor2" link="classsigc_1_1const__mem__functor2.html#a6265bdc51f35d8d5274bfeb8cdafc1dc" type="function"/>
+ <keyword name="sigc::const_mem_functor2::const_mem_functor2" link="classsigc_1_1const__mem__functor2.html#ab281b110d1fbba86e2d58f9607d0f0c3" type="function"/>
+ <keyword name="sigc::const_mem_functor2::operator()" link="classsigc_1_1const__mem__functor2.html#aafbf14880952214525553f4b419bf5c6" type="function"/>
+ <keyword name="sigc::const_mem_functor2::operator()" link="classsigc_1_1const__mem__functor2.html#a51c12b33270c350c8988194cb29df590" type="function"/>
+ <keyword type="struct" name="sigc::const_mem_functor3" link="classsigc_1_1const__mem__functor3.html"/>
+ <keyword name="sigc::const_mem_functor3::function_type" link="classsigc_1_1const__mem__functor3.html#accd266c72527ca411756bd9a4045eac9" type="typedef"/>
+ <keyword name="sigc::const_mem_functor3::result_type" link="classsigc_1_1const__mem__functor3.html#ae67fd219e64f81359640873d30123c9d" type="typedef"/>
+ <keyword name="sigc::const_mem_functor3::const_mem_functor3" link="classsigc_1_1const__mem__functor3.html#a9921cf28137404e029e3f5d7c291021d" type="function"/>
+ <keyword name="sigc::const_mem_functor3::const_mem_functor3" link="classsigc_1_1const__mem__functor3.html#ae70cb6e5e322ef3f3a9673b1e541d2c1" type="function"/>
+ <keyword name="sigc::const_mem_functor3::operator()" link="classsigc_1_1const__mem__functor3.html#aa123c4fb39116ca1a28896cfd029b1de" type="function"/>
+ <keyword name="sigc::const_mem_functor3::operator()" link="classsigc_1_1const__mem__functor3.html#a6322fdc9cc492d4f3a2c8482e193540f" type="function"/>
+ <keyword type="struct" name="sigc::const_mem_functor4" link="classsigc_1_1const__mem__functor4.html"/>
+ <keyword name="sigc::const_mem_functor4::function_type" link="classsigc_1_1const__mem__functor4.html#a775bb61661f2a7007b36f16ee106a8ad" type="typedef"/>
+ <keyword name="sigc::const_mem_functor4::result_type" link="classsigc_1_1const__mem__functor4.html#a78069750e64446199d91c0682b0915cc" type="typedef"/>
+ <keyword name="sigc::const_mem_functor4::const_mem_functor4" link="classsigc_1_1const__mem__functor4.html#acdde68d1638c13cd29157d1cb1bd42d2" type="function"/>
+ <keyword name="sigc::const_mem_functor4::const_mem_functor4" link="classsigc_1_1const__mem__functor4.html#a7e09703c6320542cb5f0075d371908a8" type="function"/>
+ <keyword name="sigc::const_mem_functor4::operator()" link="classsigc_1_1const__mem__functor4.html#a25b73f70e0cb8771a6fc8dd1ad521795" type="function"/>
+ <keyword name="sigc::const_mem_functor4::operator()" link="classsigc_1_1const__mem__functor4.html#a5b178876ca9fbec1fa2339819939a9e7" type="function"/>
+ <keyword type="struct" name="sigc::const_mem_functor5" link="classsigc_1_1const__mem__functor5.html"/>
+ <keyword name="sigc::const_mem_functor5::function_type" link="classsigc_1_1const__mem__functor5.html#aa58310b256b11e94d9a757acf60b410a" type="typedef"/>
+ <keyword name="sigc::const_mem_functor5::result_type" link="classsigc_1_1const__mem__functor5.html#a9d952d52dade789bc38953c4c83fb425" type="typedef"/>
+ <keyword name="sigc::const_mem_functor5::const_mem_functor5" link="classsigc_1_1const__mem__functor5.html#a818da40f7c82d6a1fde3009d32bf3920" type="function"/>
+ <keyword name="sigc::const_mem_functor5::const_mem_functor5" link="classsigc_1_1const__mem__functor5.html#a47769ef46d8ff779df8c152acdc0d74c" type="function"/>
+ <keyword name="sigc::const_mem_functor5::operator()" link="classsigc_1_1const__mem__functor5.html#aaceffe6505aed22dd5af369231914965" type="function"/>
+ <keyword name="sigc::const_mem_functor5::operator()" link="classsigc_1_1const__mem__functor5.html#ae710c03998c58cb8f90ce75a46fab69c" type="function"/>
+ <keyword type="struct" name="sigc::const_mem_functor6" link="classsigc_1_1const__mem__functor6.html"/>
+ <keyword name="sigc::const_mem_functor6::function_type" link="classsigc_1_1const__mem__functor6.html#ad64803b1192e1007887f234b8c7421ac" type="typedef"/>
+ <keyword name="sigc::const_mem_functor6::result_type" link="classsigc_1_1const__mem__functor6.html#adf81aebfa633d0bf14a0d3f5e9688561" type="typedef"/>
+ <keyword name="sigc::const_mem_functor6::const_mem_functor6" link="classsigc_1_1const__mem__functor6.html#a7a5e8a3a981a615a545aab358efa9472" type="function"/>
+ <keyword name="sigc::const_mem_functor6::const_mem_functor6" link="classsigc_1_1const__mem__functor6.html#a0803b89f79b60c16d87c0372be261211" type="function"/>
+ <keyword name="sigc::const_mem_functor6::operator()" link="classsigc_1_1const__mem__functor6.html#a8657b806cb2eeb7e43f0a09f6556c514" type="function"/>
+ <keyword name="sigc::const_mem_functor6::operator()" link="classsigc_1_1const__mem__functor6.html#a023fd4cb845234b50c5dee1f4147cde9" type="function"/>
+ <keyword type="struct" name="sigc::const_mem_functor7" link="classsigc_1_1const__mem__functor7.html"/>
+ <keyword name="sigc::const_mem_functor7::function_type" link="classsigc_1_1const__mem__functor7.html#a73af81d23d0fa816b8ef00acb1970d43" type="typedef"/>
+ <keyword name="sigc::const_mem_functor7::result_type" link="classsigc_1_1const__mem__functor7.html#a724b8b210493e0d3cf06b5a393b91546" type="typedef"/>
+ <keyword name="sigc::const_mem_functor7::const_mem_functor7" link="classsigc_1_1const__mem__functor7.html#add4d7f74905c6bc20afc6f7681f367c0" type="function"/>
+ <keyword name="sigc::const_mem_functor7::const_mem_functor7" link="classsigc_1_1const__mem__functor7.html#a0538bba01694fc13456fcee0e96d8f34" type="function"/>
+ <keyword name="sigc::const_mem_functor7::operator()" link="classsigc_1_1const__mem__functor7.html#ab49dc9f302ef22e4b76043d9bc2f5062" type="function"/>
+ <keyword name="sigc::const_mem_functor7::operator()" link="classsigc_1_1const__mem__functor7.html#a53f19248e5b61460759d7cdbf41ca21b" type="function"/>
+ <keyword type="struct" name="sigc::const_reference_wrapper" link="structsigc_1_1const__reference__wrapper.html"/>
+ <keyword name="sigc::const_reference_wrapper::const_reference_wrapper" link="structsigc_1_1const__reference__wrapper.html#a249ae888fb9be126598d81ce339fbf81" type="function"/>
+ <keyword name="sigc::const_reference_wrapper::operator const T_type &" link="structsigc_1_1const__reference__wrapper.html#a2cf7a981855668dfb69e98cfaa6eb779" type="function"/>
+ <keyword type="struct" name="sigc::const_volatile_limit_reference" link="classsigc_1_1const__volatile__limit__reference.html"/>
+ <keyword name="sigc::const_volatile_limit_reference::const_volatile_limit_reference" link="classsigc_1_1const__volatile__limit__reference.html#a9a01809bae79cb1b13ee50ce9d84dcb8" type="function"/>
+ <keyword name="sigc::const_volatile_limit_reference::invoke" link="classsigc_1_1const__volatile__limit__reference.html#ac09d022e8991a946d49a714df8b2f1c7" type="function"/>
+ <keyword name="sigc::const_volatile_limit_reference::visit" link="classsigc_1_1const__volatile__limit__reference.html#a41c17ef86e8c65998ba42097c7ad5f09" type="function"/>
+ <keyword type="struct" name="sigc::const_volatile_limit_reference< T_type, true >" link="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html"/>
+ <keyword name="sigc::const_volatile_limit_reference< T_type, true >::const_volatile_limit_reference" link="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html#a94bf04779d798bd2737c521d20655122" type="function"/>
+ <keyword name="sigc::const_volatile_limit_reference< T_type, true >::invoke" link="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html#a0a44e756c7478717ef8b34fb5b0c7004" type="function"/>
+ <keyword name="sigc::const_volatile_limit_reference< T_type, true >::visit" link="classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html#a332d07b8ef0005163f02df234f014814" type="function"/>
+ <keyword type="struct" name="sigc::const_volatile_mem_functor0" link="classsigc_1_1const__volatile__mem__functor0.html"/>
+ <keyword name="sigc::const_volatile_mem_functor0::function_type" link="classsigc_1_1const__volatile__mem__functor0.html#a3247f7d0e3804ff455e0996b969f6c59" type="typedef"/>
+ <keyword name="sigc::const_volatile_mem_functor0::result_type" link="classsigc_1_1const__volatile__mem__functor0.html#ab8e419ef5ad21d6230a306cd7d910df9" type="typedef"/>
+ <keyword name="sigc::const_volatile_mem_functor0::const_volatile_mem_functor0" link="classsigc_1_1const__volatile__mem__functor0.html#a8eec4c4ff04b8d5ef7c184e853ea0486" type="function"/>
+ <keyword name="sigc::const_volatile_mem_functor0::const_volatile_mem_functor0" link="classsigc_1_1const__volatile__mem__functor0.html#ab20dd00a6c8908a8ebd7846985d71856" type="function"/>
+ <keyword name="sigc::const_volatile_mem_functor0::operator()" link="classsigc_1_1const__volatile__mem__functor0.html#adfd64d64707c012329915edf19190772" type="function"/>
+ <keyword name="sigc::const_volatile_mem_functor0::operator()" link="classsigc_1_1const__volatile__mem__functor0.html#a86005d47b02e980c90d135a636e21674" type="function"/>
+ <keyword type="struct" name="sigc::const_volatile_mem_functor1" link="classsigc_1_1const__volatile__mem__functor1.html"/>
+ <keyword name="sigc::const_volatile_mem_functor1::function_type" link="classsigc_1_1const__volatile__mem__functor1.html#acc367f8d6ee646c370623650a7ed6cde" type="typedef"/>
+ <keyword name="sigc::const_volatile_mem_functor1::result_type" link="classsigc_1_1const__volatile__mem__functor1.html#adeaf82cc2aff607efe2a51945d6b8565" type="typedef"/>
+ <keyword name="sigc::const_volatile_mem_functor1::const_volatile_mem_functor1" link="classsigc_1_1const__volatile__mem__functor1.html#a25a541c4bef874a6b2d177a3be7ab988" type="function"/>
+ <keyword name="sigc::const_volatile_mem_functor1::const_volatile_mem_functor1" link="classsigc_1_1const__volatile__mem__functor1.html#aa8cb4ad934ac610ffe3425cbe799ba8d" type="function"/>
+ <keyword name="sigc::const_volatile_mem_functor1::operator()" link="classsigc_1_1const__volatile__mem__functor1.html#a715b1d5c56a537cbd397875e8eba532d" type="function"/>
+ <keyword name="sigc::const_volatile_mem_functor1::operator()" link="classsigc_1_1const__volatile__mem__functor1.html#a9af06968e1db65f5bd136175e10d250f" type="function"/>
+ <keyword type="struct" name="sigc::const_volatile_mem_functor2" link="classsigc_1_1const__volatile__mem__functor2.html"/>
+ <keyword name="sigc::const_volatile_mem_functor2::function_type" link="classsigc_1_1const__volatile__mem__functor2.html#ac46d1e343e669092d6bb24aa8b5d5dbb" type="typedef"/>
+ <keyword name="sigc::const_volatile_mem_functor2::result_type" link="classsigc_1_1const__volatile__mem__functor2.html#a0d143bb32627f7a0c17270321df8145f" type="typedef"/>
+ <keyword name="sigc::const_volatile_mem_functor2::const_volatile_mem_functor2" link="classsigc_1_1const__volatile__mem__functor2.html#ad99060cf675fb65cbc00f2b8e9ec3068" type="function"/>
+ <keyword name="sigc::const_volatile_mem_functor2::const_volatile_mem_functor2" link="classsigc_1_1const__volatile__mem__functor2.html#ada3da9a8dd692377c90abbfa9bcfe73a" type="function"/>
+ <keyword name="sigc::const_volatile_mem_functor2::operator()" link="classsigc_1_1const__volatile__mem__functor2.html#a467a45cf9bc54bed0f3c5bade3329067" type="function"/>
+ <keyword name="sigc::const_volatile_mem_functor2::operator()" link="classsigc_1_1const__volatile__mem__functor2.html#a9d024cf10df876df77183e1fb79a52ec" type="function"/>
+ <keyword type="struct" name="sigc::const_volatile_mem_functor3" link="classsigc_1_1const__volatile__mem__functor3.html"/>
+ <keyword name="sigc::const_volatile_mem_functor3::function_type" link="classsigc_1_1const__volatile__mem__functor3.html#a472ab7835e2b6792a108f4fcc80d4669" type="typedef"/>
+ <keyword name="sigc::const_volatile_mem_functor3::result_type" link="classsigc_1_1const__volatile__mem__functor3.html#ad2056f73eed4664ff41f5e673a2276f0" type="typedef"/>
+ <keyword name="sigc::const_volatile_mem_functor3::const_volatile_mem_functor3" link="classsigc_1_1const__volatile__mem__functor3.html#af284f300a6b3696f6379dcc9ed97a744" type="function"/>
+ <keyword name="sigc::const_volatile_mem_functor3::const_volatile_mem_functor3" link="classsigc_1_1const__volatile__mem__functor3.html#aa586f24064b6a5c8b69c963fff614d04" type="function"/>
+ <keyword name="sigc::const_volatile_mem_functor3::operator()" link="classsigc_1_1const__volatile__mem__functor3.html#a4af918f707067763bb2031d8758991d5" type="function"/>
+ <keyword name="sigc::const_volatile_mem_functor3::operator()" link="classsigc_1_1const__volatile__mem__functor3.html#a47374a80a3a61b69e39478ca9a4a4776" type="function"/>
+ <keyword type="struct" name="sigc::const_volatile_mem_functor4" link="classsigc_1_1const__volatile__mem__functor4.html"/>
+ <keyword name="sigc::const_volatile_mem_functor4::function_type" link="classsigc_1_1const__volatile__mem__functor4.html#ace3cb54e6265ebe06ee2995dd01f2540" type="typedef"/>
+ <keyword name="sigc::const_volatile_mem_functor4::result_type" link="classsigc_1_1const__volatile__mem__functor4.html#a8e38a0816627c7ad4fd48278d287f863" type="typedef"/>
+ <keyword name="sigc::const_volatile_mem_functor4::const_volatile_mem_functor4" link="classsigc_1_1const__volatile__mem__functor4.html#aad7b7f5037a0c8d13668f9c350e010ee" type="function"/>
+ <keyword name="sigc::const_volatile_mem_functor4::const_volatile_mem_functor4" link="classsigc_1_1const__volatile__mem__functor4.html#a0ffe59d6392c736e6d14c43a4bfa26e5" type="function"/>
+ <keyword name="sigc::const_volatile_mem_functor4::operator()" link="classsigc_1_1const__volatile__mem__functor4.html#a7cd0900e7e3c8523503e037e7c696f5d" type="function"/>
+ <keyword name="sigc::const_volatile_mem_functor4::operator()" link="classsigc_1_1const__volatile__mem__functor4.html#a589c68eddffeb3399838d2af7f5b6d19" type="function"/>
+ <keyword type="struct" name="sigc::const_volatile_mem_functor5" link="classsigc_1_1const__volatile__mem__functor5.html"/>
+ <keyword name="sigc::const_volatile_mem_functor5::function_type" link="classsigc_1_1const__volatile__mem__functor5.html#a1d49a5a7086d41d1db2e40aed1273631" type="typedef"/>
+ <keyword name="sigc::const_volatile_mem_functor5::result_type" link="classsigc_1_1const__volatile__mem__functor5.html#a42d6cd140b98358c1d12c90b975ad2b1" type="typedef"/>
+ <keyword name="sigc::const_volatile_mem_functor5::const_volatile_mem_functor5" link="classsigc_1_1const__volatile__mem__functor5.html#afe48307086c70740f39f58488a3cbdb5" type="function"/>
+ <keyword name="sigc::const_volatile_mem_functor5::const_volatile_mem_functor5" link="classsigc_1_1const__volatile__mem__functor5.html#a13787a099e237b44280ddbe9b8d97a04" type="function"/>
+ <keyword name="sigc::const_volatile_mem_functor5::operator()" link="classsigc_1_1const__volatile__mem__functor5.html#a8d74b334440d1c9add3a358cd1913b11" type="function"/>
+ <keyword name="sigc::const_volatile_mem_functor5::operator()" link="classsigc_1_1const__volatile__mem__functor5.html#a7b1fde7647e7e936b29c97797835ca7b" type="function"/>
+ <keyword type="struct" name="sigc::const_volatile_mem_functor6" link="classsigc_1_1const__volatile__mem__functor6.html"/>
+ <keyword name="sigc::const_volatile_mem_functor6::function_type" link="classsigc_1_1const__volatile__mem__functor6.html#af8da04ac5f6e2252f963f4f4bb87c9fd" type="typedef"/>
+ <keyword name="sigc::const_volatile_mem_functor6::result_type" link="classsigc_1_1const__volatile__mem__functor6.html#a9f866db08b59a0960875f7608a0c93f0" type="typedef"/>
+ <keyword name="sigc::const_volatile_mem_functor6::const_volatile_mem_functor6" link="classsigc_1_1const__volatile__mem__functor6.html#aa921f2d1cea8ddd987cdaa8df6479fab" type="function"/>
+ <keyword name="sigc::const_volatile_mem_functor6::const_volatile_mem_functor6" link="classsigc_1_1const__volatile__mem__functor6.html#a09704c72e9b0353b04776522edefd57e" type="function"/>
+ <keyword name="sigc::const_volatile_mem_functor6::operator()" link="classsigc_1_1const__volatile__mem__functor6.html#a5cf522fd8072a8f77e56cae87d65892f" type="function"/>
+ <keyword name="sigc::const_volatile_mem_functor6::operator()" link="classsigc_1_1const__volatile__mem__functor6.html#adff33012b1d7a20cb39c41c19b1db9a5" type="function"/>
+ <keyword type="struct" name="sigc::const_volatile_mem_functor7" link="classsigc_1_1const__volatile__mem__functor7.html"/>
+ <keyword name="sigc::const_volatile_mem_functor7::function_type" link="classsigc_1_1const__volatile__mem__functor7.html#a7e3bac9b817c848b96e9d1b257be1de5" type="typedef"/>
+ <keyword name="sigc::const_volatile_mem_functor7::result_type" link="classsigc_1_1const__volatile__mem__functor7.html#a25cb7e6ed71406c5b91ab2696ad8e623" type="typedef"/>
+ <keyword name="sigc::const_volatile_mem_functor7::const_volatile_mem_functor7" link="classsigc_1_1const__volatile__mem__functor7.html#ac71290a7277b022f8a8d7abc4158a7ae" type="function"/>
+ <keyword name="sigc::const_volatile_mem_functor7::const_volatile_mem_functor7" link="classsigc_1_1const__volatile__mem__functor7.html#a95dcac66fbdb4c3b92682a1ddaa0309c" type="function"/>
+ <keyword name="sigc::const_volatile_mem_functor7::operator()" link="classsigc_1_1const__volatile__mem__functor7.html#a9cb200c4d7a95edf269ede2b9c7ab060" type="function"/>
+ <keyword name="sigc::const_volatile_mem_functor7::operator()" link="classsigc_1_1const__volatile__mem__functor7.html#a1c9477eed5eef826a4666817aee9ea25" type="function"/>
+ <keyword type="struct" name="sigc::deduce_result_type" link="structsigc_1_1deduce__result__type.html"/>
+ <keyword name="sigc::deduce_result_type::type" link="structsigc_1_1deduce__result__type.html#a529a6b7809ea3ad1a2d4392b9ffcec42" type="typedef"/>
+ <keyword name="sigc::deduce_result_type::test" link="structsigc_1_1deduce__result__type.html#a46816d343f0924170208d220b7e599f4" type="function"/>
+ <keyword name="sigc::deduce_result_type::test" link="structsigc_1_1deduce__result__type.html#ab9356fdb52cf08ca8eded48bae5e5bdb" type="function"/>
+ <keyword type="struct" name="sigc::exception_catch_functor" link="structsigc_1_1exception__catch__functor.html"/>
+ <keyword name="sigc::exception_catch_functor::adaptor_type" link="structsigc_1_1exception__catch__functor.html#a5dc4ecab205c7ad5c3954c2572d4cc08" type="typedef"/>
+ <keyword name="sigc::exception_catch_functor::result_type" link="structsigc_1_1exception__catch__functor.html#a498f5575ae283594cfe03288fab54fdf" type="typedef"/>
+ <keyword name="sigc::exception_catch_functor::exception_catch_functor" link="structsigc_1_1exception__catch__functor.html#acefeea54e1d83cb64844a956598918fd" type="function"/>
+ <keyword name="sigc::exception_catch_functor::operator()" link="structsigc_1_1exception__catch__functor.html#a9f6b5068be1af2623e2aef727f2b73db" type="function"/>
+ <keyword name="sigc::exception_catch_functor::operator()" link="structsigc_1_1exception__catch__functor.html#a5472e0c6cdc3e9f0994bcd6676e7ed0f" type="function"/>
+ <keyword name="sigc::exception_catch_functor::operator()" link="structsigc_1_1exception__catch__functor.html#a00ce284a875f728da4db0b401f40c561" type="function"/>
+ <keyword name="sigc::exception_catch_functor::operator()" link="structsigc_1_1exception__catch__functor.html#aa20b567a833cdc29517f4161be5bb8b2" type="function"/>
+ <keyword name="sigc::exception_catch_functor::operator()" link="structsigc_1_1exception__catch__functor.html#a5bb82bbe1b0491cd5c53680eb5cd6b03" type="function"/>
+ <keyword name="sigc::exception_catch_functor::operator()" link="structsigc_1_1exception__catch__functor.html#aae43815dd495f34d8d519fb2dcf26102" type="function"/>
+ <keyword name="sigc::exception_catch_functor::operator()" link="structsigc_1_1exception__catch__functor.html#abc125711f5e27d38b3762e18069289ff" type="function"/>
+ <keyword name="sigc::exception_catch_functor::operator()" link="structsigc_1_1exception__catch__functor.html#a07ae1354aa93e8421c705a21cbb85ad8" type="function"/>
+ <keyword type="struct" name="sigc::exception_catch_functor< T_functor, T_catcher, void >" link="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html"/>
+ <keyword name="sigc::exception_catch_functor< T_functor, T_catcher, void >::adaptor_type" link="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#aa9803c7bd355ae0674dbfabf346676c0" type="typedef"/>
+ <keyword name="sigc::exception_catch_functor< T_functor, T_catcher, void >::result_type" link="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a06506e0d4da26682740b7f4f9aec80d5" type="typedef"/>
+ <keyword name="sigc::exception_catch_functor< T_functor, T_catcher, void >::exception_catch_functor" link="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a84b167dc0dd520253776c55eb711c461" type="function"/>
+ <keyword name="sigc::exception_catch_functor< T_functor, T_catcher, void >::exception_catch_functor" link="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a08a5ce7a94a0646e92c5eb8fb6b7d5f3" type="function"/>
+ <keyword name="sigc::exception_catch_functor< T_functor, T_catcher, void >::~exception_catch_functor" link="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a1537e7d0175046d65522bd960149bb62" type="function"/>
+ <keyword name="sigc::exception_catch_functor< T_functor, T_catcher, void >::operator()" link="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a24e842daf8e8d756e2b77ceb47c55c14" type="function"/>
+ <keyword name="sigc::exception_catch_functor< T_functor, T_catcher, void >::operator()" link="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#ade12d3049fdb07307d0852aa9a90f1b6" type="function"/>
+ <keyword name="sigc::exception_catch_functor< T_functor, T_catcher, void >::operator()" link="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a552ee97ff7ee248d75ecd0241d379d31" type="function"/>
+ <keyword name="sigc::exception_catch_functor< T_functor, T_catcher, void >::operator()" link="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a4062190405963d2bf806219d3480b2dd" type="function"/>
+ <keyword name="sigc::exception_catch_functor< T_functor, T_catcher, void >::operator()" link="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a68bec561e3c051fc3551965ccbad4398" type="function"/>
+ <keyword name="sigc::exception_catch_functor< T_functor, T_catcher, void >::operator()" link="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a1eb6fb5783d65d904474f6ffe14ace7b" type="function"/>
+ <keyword name="sigc::exception_catch_functor< T_functor, T_catcher, void >::operator()" link="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#a4c24ffa31304c0647b0d29cba07ffe3a" type="function"/>
+ <keyword name="sigc::exception_catch_functor< T_functor, T_catcher, void >::operator()" link="structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html#ab4d0d68e2dd1d356ff932ac2ca846a0c" type="function"/>
+ <keyword type="struct" name="sigc::functor_base" link="structsigc_1_1functor__base.html"/>
+ <keyword type="struct" name="sigc::functor_trait" link="structsigc_1_1functor__trait.html"/>
+ <keyword name="sigc::functor_trait::functor_type" link="structsigc_1_1functor__trait.html#ac779b3d3d04e78d57b6b2ae4545b1667" type="typedef"/>
+ <keyword name="sigc::functor_trait::result_type" link="structsigc_1_1functor__trait.html#af1324bf0d3cec3d1f2e39e932b228d6d" type="typedef"/>
+ <keyword type="struct" name="sigc::hide_functor" link="structsigc_1_1hide__functor.html"/>
+ <keyword type="struct" name="sigc::hide_functor< 0, T_functor >" link="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html"/>
+ <keyword name="sigc::hide_functor< 0, T_functor >::adaptor_type" link="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a33b1c4635aad21aac771627a9a9fe60f" type="typedef"/>
+ <keyword name="sigc::hide_functor< 0, T_functor >::result_type" link="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#af5b5ee49bb277471b5bc8e3769d0dcb7" type="typedef"/>
+ <keyword name="sigc::hide_functor< 0, T_functor >::hide_functor" link="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a7d5504f337ab7a4b6f709219c9e98222" type="function"/>
+ <keyword name="sigc::hide_functor< 0, T_functor >::operator()" link="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a556774f196a4ec5569e8404ba8ae1539" type="function"/>
+ <keyword name="sigc::hide_functor< 0, T_functor >::operator()" link="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#ad6b459b35d0bf0e337fdef4780e68840" type="function"/>
+ <keyword name="sigc::hide_functor< 0, T_functor >::operator()" link="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a5390f82ac4049f2a22ef1f4896a508dd" type="function"/>
+ <keyword name="sigc::hide_functor< 0, T_functor >::operator()" link="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a587bc5d423b0b38722764c9f0792e73c" type="function"/>
+ <keyword name="sigc::hide_functor< 0, T_functor >::operator()" link="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a9c8415cad0f615bb1a24cf8e8a985cf7" type="function"/>
+ <keyword name="sigc::hide_functor< 0, T_functor >::operator()" link="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a62027eafacff15f5f7efaefd204f1908" type="function"/>
+ <keyword name="sigc::hide_functor< 0, T_functor >::operator()" link="structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html#a599128c72562bd8de98c37f046471080" type="function"/>
+ <keyword type="struct" name="sigc::hide_functor<-1, T_functor >" link="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html"/>
+ <keyword name="sigc::hide_functor<-1, T_functor >::adaptor_type" link="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a1f2c49ddcd02a3b7f240f0d0e6f0eec5" type="typedef"/>
+ <keyword name="sigc::hide_functor<-1, T_functor >::result_type" link="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a72ea0ce5ad7cf4f9e0e7b160d830c5a4" type="typedef"/>
+ <keyword name="sigc::hide_functor<-1, T_functor >::hide_functor" link="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a4c8d774e447991a6a920b9f3fca63205" type="function"/>
+ <keyword name="sigc::hide_functor<-1, T_functor >::operator()" link="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a3ab506b688835f9545dc018142cc728e" type="function"/>
+ <keyword name="sigc::hide_functor<-1, T_functor >::operator()" link="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a4c9d0e81c0dacb65443b810ba90f81b7" type="function"/>
+ <keyword name="sigc::hide_functor<-1, T_functor >::operator()" link="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a1b14612df4daabfa76ddb5aa9d48c023" type="function"/>
+ <keyword name="sigc::hide_functor<-1, T_functor >::operator()" link="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a576f3873a5e2444cec82b04f82b1e01e" type="function"/>
+ <keyword name="sigc::hide_functor<-1, T_functor >::operator()" link="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a8a00e3b27c18520ff693b379aa3db3da" type="function"/>
+ <keyword name="sigc::hide_functor<-1, T_functor >::operator()" link="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#af4b6fe456f259ae4a9973c2feaebb9f5" type="function"/>
+ <keyword name="sigc::hide_functor<-1, T_functor >::operator()" link="structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html#a0b2aed34c7b1c58fc9735ec4578bd6c2" type="function"/>
+ <keyword type="struct" name="sigc::limit_reference" link="classsigc_1_1limit__reference.html"/>
+ <keyword name="sigc::limit_reference::limit_reference" link="classsigc_1_1limit__reference.html#a58bf17e1eaa63d86336c831fa885bc66" type="function"/>
+ <keyword name="sigc::limit_reference::invoke" link="classsigc_1_1limit__reference.html#affd2902cd78ccdae45c499058c83e992" type="function"/>
+ <keyword name="sigc::limit_reference::visit" link="classsigc_1_1limit__reference.html#affeb3929fdc606c8fb7f8f29fa6fd12d" type="function"/>
+ <keyword type="struct" name="sigc::limit_reference< T_type, true >" link="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html"/>
+ <keyword name="sigc::limit_reference< T_type, true >::limit_reference" link="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html#a26ef98ef1f11a4b5891d426e9722c2c8" type="function"/>
+ <keyword name="sigc::limit_reference< T_type, true >::invoke" link="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html#a6c8067da8b8c15361127ad25efab6903" type="function"/>
+ <keyword name="sigc::limit_reference< T_type, true >::visit" link="classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html#a85e56a8140929d71b2bdbd091e348c3a" type="function"/>
+ <keyword type="struct" name="sigc::mem_functor0" link="classsigc_1_1mem__functor0.html"/>
+ <keyword name="sigc::mem_functor0::function_type" link="classsigc_1_1mem__functor0.html#a2b54ee0f1d0b0ca4f25707c85a5d4bab" type="typedef"/>
+ <keyword name="sigc::mem_functor0::result_type" link="classsigc_1_1mem__functor0.html#aa679f73c7b786540686c110628a71dde" type="typedef"/>
+ <keyword name="sigc::mem_functor0::mem_functor0" link="classsigc_1_1mem__functor0.html#ad598cd301fc54f3aa4da2b9e3c16bc81" type="function"/>
+ <keyword name="sigc::mem_functor0::mem_functor0" link="classsigc_1_1mem__functor0.html#a5655f48c6f36716dc15daf584f20d51c" type="function"/>
+ <keyword name="sigc::mem_functor0::operator()" link="classsigc_1_1mem__functor0.html#a51d5213c9d41b51e3b8cca705bd801cc" type="function"/>
+ <keyword name="sigc::mem_functor0::operator()" link="classsigc_1_1mem__functor0.html#a0a8b70a8f59ddbdc3f1a9892c634bf48" type="function"/>
+ <keyword type="struct" name="sigc::mem_functor1" link="classsigc_1_1mem__functor1.html"/>
+ <keyword name="sigc::mem_functor1::function_type" link="classsigc_1_1mem__functor1.html#a4f10314fc4d7811e126aa0d8dc9fea8c" type="typedef"/>
+ <keyword name="sigc::mem_functor1::result_type" link="classsigc_1_1mem__functor1.html#a7c7ab28530e2f678eae87772253df709" type="typedef"/>
+ <keyword name="sigc::mem_functor1::mem_functor1" link="classsigc_1_1mem__functor1.html#ab97c2206275025d8d1e7665c12322eba" type="function"/>
+ <keyword name="sigc::mem_functor1::mem_functor1" link="classsigc_1_1mem__functor1.html#a63230b348e410f7d2f245df1f2af019a" type="function"/>
+ <keyword name="sigc::mem_functor1::operator()" link="classsigc_1_1mem__functor1.html#a55a370a320def89e80aa37141c101c98" type="function"/>
+ <keyword name="sigc::mem_functor1::operator()" link="classsigc_1_1mem__functor1.html#a11fa461ba0bbddc9e5a7dd687e90591b" type="function"/>
+ <keyword type="struct" name="sigc::mem_functor2" link="classsigc_1_1mem__functor2.html"/>
+ <keyword name="sigc::mem_functor2::function_type" link="classsigc_1_1mem__functor2.html#aa584cfe15bb8dc5b2931d2bfd034c118" type="typedef"/>
+ <keyword name="sigc::mem_functor2::result_type" link="classsigc_1_1mem__functor2.html#a9080e942d35d226ea6f9dda097342f07" type="typedef"/>
+ <keyword name="sigc::mem_functor2::mem_functor2" link="classsigc_1_1mem__functor2.html#a691e21d47b7a54b67605812f7e089299" type="function"/>
+ <keyword name="sigc::mem_functor2::mem_functor2" link="classsigc_1_1mem__functor2.html#aeee1c7f263f8d7e7b6fa9be0156878fe" type="function"/>
+ <keyword name="sigc::mem_functor2::operator()" link="classsigc_1_1mem__functor2.html#a6fe02ecb626919c1149888b03fde552e" type="function"/>
+ <keyword name="sigc::mem_functor2::operator()" link="classsigc_1_1mem__functor2.html#ad5d0f74803537d1ed8b9678ac2da57d5" type="function"/>
+ <keyword type="struct" name="sigc::mem_functor3" link="classsigc_1_1mem__functor3.html"/>
+ <keyword name="sigc::mem_functor3::function_type" link="classsigc_1_1mem__functor3.html#a8da99a5dcfe5ae1cecd6ce93ab91b929" type="typedef"/>
+ <keyword name="sigc::mem_functor3::result_type" link="classsigc_1_1mem__functor3.html#af620103fa36aa86fb539843f7f730e01" type="typedef"/>
+ <keyword name="sigc::mem_functor3::mem_functor3" link="classsigc_1_1mem__functor3.html#abc94be96c346537bca09c73a342f5ccd" type="function"/>
+ <keyword name="sigc::mem_functor3::mem_functor3" link="classsigc_1_1mem__functor3.html#af22e274e905262144832ca9683d8823f" type="function"/>
+ <keyword name="sigc::mem_functor3::operator()" link="classsigc_1_1mem__functor3.html#a12319d24e245cf126c130de8202d91bf" type="function"/>
+ <keyword name="sigc::mem_functor3::operator()" link="classsigc_1_1mem__functor3.html#ae7496f451661d60b287d528a7cfcaf82" type="function"/>
+ <keyword type="struct" name="sigc::mem_functor4" link="classsigc_1_1mem__functor4.html"/>
+ <keyword name="sigc::mem_functor4::function_type" link="classsigc_1_1mem__functor4.html#a9dcf1ef95187c2588ecf2abb089cc7c8" type="typedef"/>
+ <keyword name="sigc::mem_functor4::result_type" link="classsigc_1_1mem__functor4.html#a79bf0a3c25dbe6eb07829ee55ce5d664" type="typedef"/>
+ <keyword name="sigc::mem_functor4::mem_functor4" link="classsigc_1_1mem__functor4.html#a9774f0ab47d023f5bccdb9960c4fcdee" type="function"/>
+ <keyword name="sigc::mem_functor4::mem_functor4" link="classsigc_1_1mem__functor4.html#a4f7841b2ccd26fac6c21bf04fc524e08" type="function"/>
+ <keyword name="sigc::mem_functor4::operator()" link="classsigc_1_1mem__functor4.html#a37b49e119c9be15f15362fe44eadc6a2" type="function"/>
+ <keyword name="sigc::mem_functor4::operator()" link="classsigc_1_1mem__functor4.html#aef140dac7b4876793fac8a006aad0a62" type="function"/>
+ <keyword type="struct" name="sigc::mem_functor5" link="classsigc_1_1mem__functor5.html"/>
+ <keyword name="sigc::mem_functor5::function_type" link="classsigc_1_1mem__functor5.html#a66e9bb0c9829b13af029ee2127b54eb5" type="typedef"/>
+ <keyword name="sigc::mem_functor5::result_type" link="classsigc_1_1mem__functor5.html#a3e0587ce338328d42f44c4e5f79be6ed" type="typedef"/>
+ <keyword name="sigc::mem_functor5::mem_functor5" link="classsigc_1_1mem__functor5.html#a9048a4a2216e20f9f34380020f5b67ec" type="function"/>
+ <keyword name="sigc::mem_functor5::mem_functor5" link="classsigc_1_1mem__functor5.html#a01bdff47bf4aed8c52fdfd5520fdf3cf" type="function"/>
+ <keyword name="sigc::mem_functor5::operator()" link="classsigc_1_1mem__functor5.html#af1ce121edd0248d104f95e239af683bd" type="function"/>
+ <keyword name="sigc::mem_functor5::operator()" link="classsigc_1_1mem__functor5.html#a7ad7a4d81470125047755dfa8509c6dc" type="function"/>
+ <keyword type="struct" name="sigc::mem_functor6" link="classsigc_1_1mem__functor6.html"/>
+ <keyword name="sigc::mem_functor6::function_type" link="classsigc_1_1mem__functor6.html#a202287b72f6213f64a696b185fb90268" type="typedef"/>
+ <keyword name="sigc::mem_functor6::result_type" link="classsigc_1_1mem__functor6.html#af80425ff57ca2115cba771c275f49e36" type="typedef"/>
+ <keyword name="sigc::mem_functor6::mem_functor6" link="classsigc_1_1mem__functor6.html#aaa43195f4b4e39c76c10478539d35172" type="function"/>
+ <keyword name="sigc::mem_functor6::mem_functor6" link="classsigc_1_1mem__functor6.html#aabc6bb723e0831e27a0a9131525d96bc" type="function"/>
+ <keyword name="sigc::mem_functor6::operator()" link="classsigc_1_1mem__functor6.html#a4a322216c1783eb8ad7f63972b3a1164" type="function"/>
+ <keyword name="sigc::mem_functor6::operator()" link="classsigc_1_1mem__functor6.html#afc40dbe8ea11726018dfa7c1ca435f3d" type="function"/>
+ <keyword type="struct" name="sigc::mem_functor7" link="classsigc_1_1mem__functor7.html"/>
+ <keyword name="sigc::mem_functor7::function_type" link="classsigc_1_1mem__functor7.html#a408f0afec5b4c750ca8e1bdab0f8b535" type="typedef"/>
+ <keyword name="sigc::mem_functor7::result_type" link="classsigc_1_1mem__functor7.html#a967b5f6572e988ea0833818b993745f9" type="typedef"/>
+ <keyword name="sigc::mem_functor7::mem_functor7" link="classsigc_1_1mem__functor7.html#afbb9b8ecaa25e0dd85c0f3d539f198b4" type="function"/>
+ <keyword name="sigc::mem_functor7::mem_functor7" link="classsigc_1_1mem__functor7.html#a79de1ccebb568e82b7f7a67ab85e4dc6" type="function"/>
+ <keyword name="sigc::mem_functor7::operator()" link="classsigc_1_1mem__functor7.html#ad8e9031dc12742265d834a5529b1f00d" type="function"/>
+ <keyword name="sigc::mem_functor7::operator()" link="classsigc_1_1mem__functor7.html#ab95293e358caf96b5dbf123f024eed8d" type="function"/>
+ <keyword type="struct" name="sigc::nil" link="structsigc_1_1nil.html"/>
+ <keyword type="struct" name="sigc::pointer_functor0" link="classsigc_1_1pointer__functor0.html"/>
+ <keyword name="sigc::pointer_functor0::result_type" link="classsigc_1_1pointer__functor0.html#af44316e53e33b4184ca151b6b11c70e5" type="typedef"/>
+ <keyword name="sigc::pointer_functor0::pointer_functor0" link="classsigc_1_1pointer__functor0.html#afdb67f682e7b9190f646eed879dcfbe4" type="function"/>
+ <keyword name="sigc::pointer_functor0::pointer_functor0" link="classsigc_1_1pointer__functor0.html#a9ae3efd5c13c738db815f619499004d7" type="function"/>
+ <keyword name="sigc::pointer_functor0::operator()" link="classsigc_1_1pointer__functor0.html#a56db821303c19ec3345679d80d6ef96e" type="function"/>
+ <keyword type="struct" name="sigc::pointer_functor1" link="classsigc_1_1pointer__functor1.html"/>
+ <keyword name="sigc::pointer_functor1::result_type" link="classsigc_1_1pointer__functor1.html#a4080910d23a74b102a123838fa93e90b" type="typedef"/>
+ <keyword name="sigc::pointer_functor1::pointer_functor1" link="classsigc_1_1pointer__functor1.html#a6ce467c0641f8e3e0d91f3b843b07c3f" type="function"/>
+ <keyword name="sigc::pointer_functor1::pointer_functor1" link="classsigc_1_1pointer__functor1.html#a8ab0c5b707dc41a821c63769344db2cb" type="function"/>
+ <keyword name="sigc::pointer_functor1::operator()" link="classsigc_1_1pointer__functor1.html#a3c978e35c107326078f3e33afcdd1235" type="function"/>
+ <keyword type="struct" name="sigc::pointer_functor2" link="classsigc_1_1pointer__functor2.html"/>
+ <keyword name="sigc::pointer_functor2::result_type" link="classsigc_1_1pointer__functor2.html#a297b784eb0cea07b364c854e5dd5f864" type="typedef"/>
+ <keyword name="sigc::pointer_functor2::pointer_functor2" link="classsigc_1_1pointer__functor2.html#a2977aa1d72f5f0fd6c778b60ad791b9c" type="function"/>
+ <keyword name="sigc::pointer_functor2::pointer_functor2" link="classsigc_1_1pointer__functor2.html#a428226381ff7bda06044c8fa53d4e27e" type="function"/>
+ <keyword name="sigc::pointer_functor2::operator()" link="classsigc_1_1pointer__functor2.html#af3d1d778be1730e170c42c52511d6926" type="function"/>
+ <keyword type="struct" name="sigc::pointer_functor3" link="classsigc_1_1pointer__functor3.html"/>
+ <keyword name="sigc::pointer_functor3::result_type" link="classsigc_1_1pointer__functor3.html#a2a0ed29803c02cc62fcc6497f83f88bf" type="typedef"/>
+ <keyword name="sigc::pointer_functor3::pointer_functor3" link="classsigc_1_1pointer__functor3.html#a1a4909d1444e4456a89eb5852933d1cc" type="function"/>
+ <keyword name="sigc::pointer_functor3::pointer_functor3" link="classsigc_1_1pointer__functor3.html#aae48103ba1c48e192a04c9a1b81ae9dc" type="function"/>
+ <keyword name="sigc::pointer_functor3::operator()" link="classsigc_1_1pointer__functor3.html#adf560c1e583b2216bba4de3027e3a05e" type="function"/>
+ <keyword type="struct" name="sigc::pointer_functor4" link="classsigc_1_1pointer__functor4.html"/>
+ <keyword name="sigc::pointer_functor4::result_type" link="classsigc_1_1pointer__functor4.html#a787f8ea1c15d7bfab7643081a408401c" type="typedef"/>
+ <keyword name="sigc::pointer_functor4::pointer_functor4" link="classsigc_1_1pointer__functor4.html#ab8e3bf143e71c5ffe8f155ace0f895a8" type="function"/>
+ <keyword name="sigc::pointer_functor4::pointer_functor4" link="classsigc_1_1pointer__functor4.html#a30eaeb5f9974bed73d7577b862c2e06b" type="function"/>
+ <keyword name="sigc::pointer_functor4::operator()" link="classsigc_1_1pointer__functor4.html#a42875d789a30fb04395dbef76d720989" type="function"/>
+ <keyword type="struct" name="sigc::pointer_functor5" link="classsigc_1_1pointer__functor5.html"/>
+ <keyword name="sigc::pointer_functor5::result_type" link="classsigc_1_1pointer__functor5.html#a00dcbec8a920ea784e3210743c77855b" type="typedef"/>
+ <keyword name="sigc::pointer_functor5::pointer_functor5" link="classsigc_1_1pointer__functor5.html#aa86bb74ff5e188f8f6497b7e73621cdd" type="function"/>
+ <keyword name="sigc::pointer_functor5::pointer_functor5" link="classsigc_1_1pointer__functor5.html#abf1e06db145e4554ec53964ca79171cf" type="function"/>
+ <keyword name="sigc::pointer_functor5::operator()" link="classsigc_1_1pointer__functor5.html#aa2f399d3f76e802670c8a08ede82c40c" type="function"/>
+ <keyword type="struct" name="sigc::pointer_functor6" link="classsigc_1_1pointer__functor6.html"/>
+ <keyword name="sigc::pointer_functor6::result_type" link="classsigc_1_1pointer__functor6.html#a9fd7af745ebad4d59f67e0f60fb395e0" type="typedef"/>
+ <keyword name="sigc::pointer_functor6::pointer_functor6" link="classsigc_1_1pointer__functor6.html#a26551fa703a65a9a14190c7579a3b77d" type="function"/>
+ <keyword name="sigc::pointer_functor6::pointer_functor6" link="classsigc_1_1pointer__functor6.html#ab56acb7713cf87d0b3094adc4ffe7a15" type="function"/>
+ <keyword name="sigc::pointer_functor6::operator()" link="classsigc_1_1pointer__functor6.html#ac35109048b7360e1436e2b4e3a53d1cf" type="function"/>
+ <keyword type="struct" name="sigc::pointer_functor7" link="classsigc_1_1pointer__functor7.html"/>
+ <keyword name="sigc::pointer_functor7::result_type" link="classsigc_1_1pointer__functor7.html#a41613e64e2b96656b85aa9eefa35aa91" type="typedef"/>
+ <keyword name="sigc::pointer_functor7::pointer_functor7" link="classsigc_1_1pointer__functor7.html#a1268abfa3437c0977517dd4cd0548080" type="function"/>
+ <keyword name="sigc::pointer_functor7::pointer_functor7" link="classsigc_1_1pointer__functor7.html#a01a6793cd057cd94bba98db3b34a3e7c" type="function"/>
+ <keyword name="sigc::pointer_functor7::operator()" link="classsigc_1_1pointer__functor7.html#a564941861ee4b84b9b61a1f247f0cfa1" type="function"/>
+ <keyword type="struct" name="sigc::reference_wrapper" link="structsigc_1_1reference__wrapper.html"/>
+ <keyword name="sigc::reference_wrapper::reference_wrapper" link="structsigc_1_1reference__wrapper.html#a05dfcad06f2af395c5e2daa9600d455a" type="function"/>
+ <keyword name="sigc::reference_wrapper::operator T_type &" link="structsigc_1_1reference__wrapper.html#ae0b2f512b6a2555b489ed9dd229efc1c" type="function"/>
+ <keyword type="struct" name="sigc::retype_functor" link="structsigc_1_1retype__functor.html"/>
+ <keyword name="sigc::retype_functor::adaptor_type" link="structsigc_1_1retype__functor.html#ace4a0fc864a6417a7cb36adf011177e0" type="typedef"/>
+ <keyword name="sigc::retype_functor::result_type" link="structsigc_1_1retype__functor.html#a1a594553d0312ca12e1009d179af0dbe" type="typedef"/>
+ <keyword name="sigc::retype_functor::retype_functor" link="structsigc_1_1retype__functor.html#a30f35ce3d25b7fd571fbd3ef730de225" type="function"/>
+ <keyword name="sigc::retype_functor::operator()" link="structsigc_1_1retype__functor.html#a841d7fd2ae795ca4decccca8342e231c" type="function"/>
+ <keyword name="sigc::retype_functor::operator()" link="structsigc_1_1retype__functor.html#abfd54e4b77096f76bb0e880b6b7b81e1" type="function"/>
+ <keyword name="sigc::retype_functor::operator()" link="structsigc_1_1retype__functor.html#a6207061ea5a530ca3d37459200ef6864" type="function"/>
+ <keyword name="sigc::retype_functor::operator()" link="structsigc_1_1retype__functor.html#a07b219886709df138ea695049f446215" type="function"/>
+ <keyword name="sigc::retype_functor::operator()" link="structsigc_1_1retype__functor.html#a66717878d5c0f2a4cb568c8ff622cb97" type="function"/>
+ <keyword name="sigc::retype_functor::operator()" link="structsigc_1_1retype__functor.html#ad60e39d45f35161727c4a57040589816" type="function"/>
+ <keyword name="sigc::retype_functor::operator()" link="structsigc_1_1retype__functor.html#a712ff55237e5e0d68195a6d5010f5b3d" type="function"/>
+ <keyword name="sigc::retype_functor::operator()" link="structsigc_1_1retype__functor.html#a7b869ff5f806496f7d99f5ae68823291" type="function"/>
+ <keyword type="struct" name="sigc::retype_return_functor" link="structsigc_1_1retype__return__functor.html"/>
+ <keyword name="sigc::retype_return_functor::result_type" link="structsigc_1_1retype__return__functor.html#aa8421dc266ad653de395e7d01e631fdc" type="typedef"/>
+ <keyword name="sigc::retype_return_functor::retype_return_functor" link="structsigc_1_1retype__return__functor.html#aa9546db86a6d1cfa7224a3a0cbad4827" type="function"/>
+ <keyword name="sigc::retype_return_functor::retype_return_functor" link="structsigc_1_1retype__return__functor.html#a9ebfb2a6cfb5125b0705c0adef2cbfb8" type="function"/>
+ <keyword name="sigc::retype_return_functor::operator()" link="structsigc_1_1retype__return__functor.html#a4cf9725b7ac4fdfeded4ab3f56d61a88" type="function"/>
+ <keyword name="sigc::retype_return_functor::operator()" link="structsigc_1_1retype__return__functor.html#aa6beb1654c027400d852e2df0fafb6aa" type="function"/>
+ <keyword name="sigc::retype_return_functor::operator()" link="structsigc_1_1retype__return__functor.html#a1352125cef26032af138aa2a327f8f66" type="function"/>
+ <keyword name="sigc::retype_return_functor::operator()" link="structsigc_1_1retype__return__functor.html#a0bcbf84c24c2195626bf4e6a2d1353b1" type="function"/>
+ <keyword name="sigc::retype_return_functor::operator()" link="structsigc_1_1retype__return__functor.html#a7e3b161bfa746f69a2af64a00af7cbd2" type="function"/>
+ <keyword name="sigc::retype_return_functor::operator()" link="structsigc_1_1retype__return__functor.html#a741b3fd8c423d3e63bdefa810e65ef44" type="function"/>
+ <keyword name="sigc::retype_return_functor::operator()" link="structsigc_1_1retype__return__functor.html#ab6c4d0b29bbcbca2e64db8249db54171" type="function"/>
+ <keyword name="sigc::retype_return_functor::operator()" link="structsigc_1_1retype__return__functor.html#a68bdb4e6cf7d505f210017ab744603f0" type="function"/>
+ <keyword type="struct" name="sigc::retype_return_functor< void, T_functor >" link="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html"/>
+ <keyword name="sigc::retype_return_functor< void, T_functor >::result_type" link="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#a64bccc59fc20fdf0fd80281597d350b2" type="typedef"/>
+ <keyword name="sigc::retype_return_functor< void, T_functor >::retype_return_functor" link="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#a720e802de29a72d1e15626b1719844bc" type="function"/>
+ <keyword name="sigc::retype_return_functor< void, T_functor >::retype_return_functor" link="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#acd4789babb601ac5bee163651d89f3c8" type="function"/>
+ <keyword name="sigc::retype_return_functor< void, T_functor >::operator()" link="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#af181f5a8134c5a834e2ad0ed7590fbfe" type="function"/>
+ <keyword name="sigc::retype_return_functor< void, T_functor >::operator()" link="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#a2ad16a9f8f247e6f7661838fb084ffd0" type="function"/>
+ <keyword name="sigc::retype_return_functor< void, T_functor >::operator()" link="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#abf17761c3eefdb3167a8562f009a8491" type="function"/>
+ <keyword name="sigc::retype_return_functor< void, T_functor >::operator()" link="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#adb392f4717b522668eb5236dbaf48e68" type="function"/>
+ <keyword name="sigc::retype_return_functor< void, T_functor >::operator()" link="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#a2c32e33b12c18d0533d4305ddd98dabe" type="function"/>
+ <keyword name="sigc::retype_return_functor< void, T_functor >::operator()" link="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#a24d383a5100302678a9a18dc5a138e51" type="function"/>
+ <keyword name="sigc::retype_return_functor< void, T_functor >::operator()" link="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#af0c3d23d0216aa0631720eb00ca8f7ef" type="function"/>
+ <keyword name="sigc::retype_return_functor< void, T_functor >::operator()" link="structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html#a73a475fd2fe5e4d9e184ca5092b0ced4" type="function"/>
+ <keyword type="struct" name="sigc::signal" link="classsigc_1_1signal.html"/>
+ <keyword name="sigc::signal::signal" link="classsigc_1_1signal.html#a50432d1aebfbee5ef17a3f434d0c50bf" type="function"/>
+ <keyword name="sigc::signal::signal" link="classsigc_1_1signal.html#a271b486daa2bf801ed7d019da9aa33a1" type="function"/>
+ <keyword name="sigc::signal::signal" link="classsigc_1_1signal.html#abc17a093db8ae8a0a8333c7f35f64bd6" type="function"/>
+ <keyword name="sigc::signal::operator=" link="classsigc_1_1signal.html#adeccc0c1c698e33c1da15c7f667f2a23" type="function"/>
+ <keyword name="sigc::signal::operator=" link="classsigc_1_1signal.html#abca2c029617e5b39f2852ee0381e7f9e" type="function"/>
+ <keyword type="struct" name="sigc::signal0" link="classsigc_1_1signal0.html"/>
+ <keyword name="sigc::signal0::const_iterator" link="classsigc_1_1signal0.html#ad4f7c62954f5c270e115d9b2a2df15ea" type="typedef"/>
+ <keyword name="sigc::signal0::const_reverse_iterator" link="classsigc_1_1signal0.html#a476f559a69eef5999c99cd6262a9aa2f" type="typedef"/>
+ <keyword name="sigc::signal0::emitter_type" link="classsigc_1_1signal0.html#ac7eafdced2d325d6003327b4360bc2dd" type="typedef"/>
+ <keyword name="sigc::signal0::iterator" link="classsigc_1_1signal0.html#ad61e875748cf4e1c2a6d89a930ae093e" type="typedef"/>
+ <keyword name="sigc::signal0::result_type" link="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de" type="typedef"/>
+ <keyword name="sigc::signal0::reverse_iterator" link="classsigc_1_1signal0.html#a1d9c390974304392ed12ee81543ab997" type="typedef"/>
+ <keyword name="sigc::signal0::slot_list_type" link="classsigc_1_1signal0.html#add195c1c738ee8efe10294f21d258b77" type="typedef"/>
+ <keyword name="sigc::signal0::slot_type" link="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287" type="typedef"/>
+ <keyword name="sigc::signal0::signal0" link="classsigc_1_1signal0.html#a2fb24e11a8f645e5122646ea2b4a5d2f" type="function"/>
+ <keyword name="sigc::signal0::signal0" link="classsigc_1_1signal0.html#a7dc687f1afb4088a3d888aa05dbf56d9" type="function"/>
+ <keyword name="sigc::signal0::signal0" link="classsigc_1_1signal0.html#ac1b915a86d0b75fd4e90c2a92f7ebc49" type="function"/>
+ <keyword name="sigc::signal0::connect" link="classsigc_1_1signal0.html#a609b1e0770f47c9081a3de56b65314d2" type="function"/>
+ <keyword name="sigc::signal0::connect" link="classsigc_1_1signal0.html#a9b78954271b6dba5e926bd960f3e7905" type="function"/>
+ <keyword name="sigc::signal0::emit" link="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8" type="function"/>
+ <keyword name="sigc::signal0::emit_reverse" link="classsigc_1_1signal0.html#abdae39f9a7abd6133c03d65224c227d6" type="function"/>
+ <keyword name="sigc::signal0::make_slot" link="classsigc_1_1signal0.html#a3295536428e5e0d6478ac10e2daff736" type="function"/>
+ <keyword name="sigc::signal0::operator()" link="classsigc_1_1signal0.html#a2dd3042c0681542ed6f2de5840f713a1" type="function"/>
+ <keyword name="sigc::signal0::operator=" link="classsigc_1_1signal0.html#a4e8311eac2fd7f8ecd10bff8225ed9e3" type="function"/>
+ <keyword name="sigc::signal0::operator=" link="classsigc_1_1signal0.html#a693aa3743236012416349bfac56d31b6" type="function"/>
+ <keyword name="sigc::signal0::slots" link="classsigc_1_1signal0.html#a5576113ddfd6b92a96f86072262307f9" type="function"/>
+ <keyword name="sigc::signal0::slots" link="classsigc_1_1signal0.html#a73523d71edd7fb4294324e9561db6f3c" type="function"/>
+ <keyword type="struct" name="sigc::signal1" link="classsigc_1_1signal1.html"/>
+ <keyword name="sigc::signal1::const_iterator" link="classsigc_1_1signal1.html#af1e262b35c9574e65b2607cdfcaad707" type="typedef"/>
+ <keyword name="sigc::signal1::const_reverse_iterator" link="classsigc_1_1signal1.html#aeb327519f808dfec9a723511ef82caa3" type="typedef"/>
+ <keyword name="sigc::signal1::emitter_type" link="classsigc_1_1signal1.html#a63c6e2b55c8c3af083402bb7f5a66593" type="typedef"/>
+ <keyword name="sigc::signal1::iterator" link="classsigc_1_1signal1.html#ab61e2d1fcaf903dffbb26b01800907fb" type="typedef"/>
+ <keyword name="sigc::signal1::result_type" link="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1" type="typedef"/>
+ <keyword name="sigc::signal1::reverse_iterator" link="classsigc_1_1signal1.html#ab0443049aa736d88770d0f534600b2bc" type="typedef"/>
+ <keyword name="sigc::signal1::slot_list_type" link="classsigc_1_1signal1.html#a5fadeb350140d6aaf560b217e7e7c4b4" type="typedef"/>
+ <keyword name="sigc::signal1::slot_type" link="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c" type="typedef"/>
+ <keyword name="sigc::signal1::signal1" link="classsigc_1_1signal1.html#aba62d8d0b9591bcfd728f8ae8a22d600" type="function"/>
+ <keyword name="sigc::signal1::signal1" link="classsigc_1_1signal1.html#ab3378dd754ffddb4760f2a3afb271dbe" type="function"/>
+ <keyword name="sigc::signal1::signal1" link="classsigc_1_1signal1.html#a85ec968e0b25ee9285f297da5416b2a4" type="function"/>
+ <keyword name="sigc::signal1::connect" link="classsigc_1_1signal1.html#aac2ade0896bd4a982777d5dd6ac75888" type="function"/>
+ <keyword name="sigc::signal1::connect" link="classsigc_1_1signal1.html#ac69d2681c586b310d8c056a319bb65fe" type="function"/>
+ <keyword name="sigc::signal1::emit" link="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42" type="function"/>
+ <keyword name="sigc::signal1::emit_reverse" link="classsigc_1_1signal1.html#a449fc940ae822c4b6ea9282b9b292015" type="function"/>
+ <keyword name="sigc::signal1::make_slot" link="classsigc_1_1signal1.html#a87513117263fd39d5a5a86e0fb8b2a78" type="function"/>
+ <keyword name="sigc::signal1::operator()" link="classsigc_1_1signal1.html#a828907c11f5c18d9522e5d5139484620" type="function"/>
+ <keyword name="sigc::signal1::operator=" link="classsigc_1_1signal1.html#a29cd06bf91f96f11c5f29237b8afbb71" type="function"/>
+ <keyword name="sigc::signal1::operator=" link="classsigc_1_1signal1.html#ab817711d4bc93402d15e87b89a09c364" type="function"/>
+ <keyword name="sigc::signal1::slots" link="classsigc_1_1signal1.html#a7653b68e6a3b8445de91f89060bf2600" type="function"/>
+ <keyword name="sigc::signal1::slots" link="classsigc_1_1signal1.html#a7777660b21fef2a6941c7dff23964604" type="function"/>
+ <keyword type="struct" name="sigc::signal2" link="classsigc_1_1signal2.html"/>
+ <keyword name="sigc::signal2::const_iterator" link="classsigc_1_1signal2.html#ad507bc5ea29adb2305f8fa91acbd30ee" type="typedef"/>
+ <keyword name="sigc::signal2::const_reverse_iterator" link="classsigc_1_1signal2.html#aacb8fe57ffe01dea5c5fb5af44634287" type="typedef"/>
+ <keyword name="sigc::signal2::emitter_type" link="classsigc_1_1signal2.html#a01379d580d21de8bc8d0d2d62e6324ea" type="typedef"/>
+ <keyword name="sigc::signal2::iterator" link="classsigc_1_1signal2.html#a658ba1c6468882c9b1d480be2bbaf55e" type="typedef"/>
+ <keyword name="sigc::signal2::result_type" link="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665" type="typedef"/>
+ <keyword name="sigc::signal2::reverse_iterator" link="classsigc_1_1signal2.html#a6710759bdeb8e626fc09d8c448e6613f" type="typedef"/>
+ <keyword name="sigc::signal2::slot_list_type" link="classsigc_1_1signal2.html#af31262f54dfb2a97540de9c4a1fc5726" type="typedef"/>
+ <keyword name="sigc::signal2::slot_type" link="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119" type="typedef"/>
+ <keyword name="sigc::signal2::signal2" link="classsigc_1_1signal2.html#a47aba9b19bc2bef0be7183022567e3ea" type="function"/>
+ <keyword name="sigc::signal2::signal2" link="classsigc_1_1signal2.html#aa634515507f2ea4a35584e12e2dc92e7" type="function"/>
+ <keyword name="sigc::signal2::signal2" link="classsigc_1_1signal2.html#a20c59f06175d4c48394c65035d2c3376" type="function"/>
+ <keyword name="sigc::signal2::connect" link="classsigc_1_1signal2.html#aa686af4f961b098a23d4f7276437c2b0" type="function"/>
+ <keyword name="sigc::signal2::connect" link="classsigc_1_1signal2.html#ab89b1876c69ea40954b0af37e75a21b4" type="function"/>
+ <keyword name="sigc::signal2::emit" link="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f" type="function"/>
+ <keyword name="sigc::signal2::emit_reverse" link="classsigc_1_1signal2.html#ad2d5f3169ba147de8d43fde9e93bac98" type="function"/>
+ <keyword name="sigc::signal2::make_slot" link="classsigc_1_1signal2.html#a844d15c61c83933575e7953b29365efa" type="function"/>
+ <keyword name="sigc::signal2::operator()" link="classsigc_1_1signal2.html#ac8b73c0624273b8dae819255961ea6a3" type="function"/>
+ <keyword name="sigc::signal2::operator=" link="classsigc_1_1signal2.html#abeb05d9a2b40882bad753fccad6522be" type="function"/>
+ <keyword name="sigc::signal2::operator=" link="classsigc_1_1signal2.html#a5d3f71fb9ee8754c4640fb5bfb954151" type="function"/>
+ <keyword name="sigc::signal2::slots" link="classsigc_1_1signal2.html#ac28b0205aa1e60cc5ce062d4d8545323" type="function"/>
+ <keyword name="sigc::signal2::slots" link="classsigc_1_1signal2.html#aa6be4804147afd56657abf5b4cf8ce3d" type="function"/>
+ <keyword type="struct" name="sigc::signal3" link="classsigc_1_1signal3.html"/>
+ <keyword name="sigc::signal3::const_iterator" link="classsigc_1_1signal3.html#a60e1ef95f82cd8981d61576d1e3f8e94" type="typedef"/>
+ <keyword name="sigc::signal3::const_reverse_iterator" link="classsigc_1_1signal3.html#a4ba3eb58c4c5ac2c25f49c48fd0af264" type="typedef"/>
+ <keyword name="sigc::signal3::emitter_type" link="classsigc_1_1signal3.html#adf54ec96c5fb78d4c8b7fc032a1937ad" type="typedef"/>
+ <keyword name="sigc::signal3::iterator" link="classsigc_1_1signal3.html#a8029a48126a2018947a2b6680ddabe6b" type="typedef"/>
+ <keyword name="sigc::signal3::result_type" link="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6" type="typedef"/>
+ <keyword name="sigc::signal3::reverse_iterator" link="classsigc_1_1signal3.html#acc453f0d5fc7f277494b2d6e737f6f68" type="typedef"/>
+ <keyword name="sigc::signal3::slot_list_type" link="classsigc_1_1signal3.html#a3bc0616e7ac933e702a889a2a84e92d4" type="typedef"/>
+ <keyword name="sigc::signal3::slot_type" link="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b" type="typedef"/>
+ <keyword name="sigc::signal3::signal3" link="classsigc_1_1signal3.html#a52731959f272612fd6abfe8850c5c8cf" type="function"/>
+ <keyword name="sigc::signal3::signal3" link="classsigc_1_1signal3.html#afe2c4320927b403b011a2538317e6c70" type="function"/>
+ <keyword name="sigc::signal3::signal3" link="classsigc_1_1signal3.html#acd69c2a1d993f0b8993f82998f76020d" type="function"/>
+ <keyword name="sigc::signal3::connect" link="classsigc_1_1signal3.html#a3eae0b3796b2736be847f33a5124aacd" type="function"/>
+ <keyword name="sigc::signal3::connect" link="classsigc_1_1signal3.html#ad71389c6d6ea60e745897579b3344d00" type="function"/>
+ <keyword name="sigc::signal3::emit" link="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb" type="function"/>
+ <keyword name="sigc::signal3::emit_reverse" link="classsigc_1_1signal3.html#a97ff4f22c97920a81e3f27aa5d39ba99" type="function"/>
+ <keyword name="sigc::signal3::make_slot" link="classsigc_1_1signal3.html#a332be8eb0ee22c11a2e1d140ca1bc2df" type="function"/>
+ <keyword name="sigc::signal3::operator()" link="classsigc_1_1signal3.html#aa7ae5338d6a883a28c61ff202e43547f" type="function"/>
+ <keyword name="sigc::signal3::operator=" link="classsigc_1_1signal3.html#a0c398a25051e920bc4338f35b4bf7df6" type="function"/>
+ <keyword name="sigc::signal3::operator=" link="classsigc_1_1signal3.html#abafd9fe17f2b9b18e25eb0293e9e8bfd" type="function"/>
+ <keyword name="sigc::signal3::slots" link="classsigc_1_1signal3.html#ab9606b708078956a758b81503f956bee" type="function"/>
+ <keyword name="sigc::signal3::slots" link="classsigc_1_1signal3.html#a742eb282312187bf8ee6992df1114781" type="function"/>
+ <keyword type="struct" name="sigc::signal4" link="classsigc_1_1signal4.html"/>
+ <keyword name="sigc::signal4::const_iterator" link="classsigc_1_1signal4.html#a3d2626edc726047c04c8fe5b9824b958" type="typedef"/>
+ <keyword name="sigc::signal4::const_reverse_iterator" link="classsigc_1_1signal4.html#a555ce030884fdf2bde788b75db01bedf" type="typedef"/>
+ <keyword name="sigc::signal4::emitter_type" link="classsigc_1_1signal4.html#acf3d1e6d6487c0ecc13ed3eab949eec7" type="typedef"/>
+ <keyword name="sigc::signal4::iterator" link="classsigc_1_1signal4.html#a31e8354263a3097bba9c63b8494143f0" type="typedef"/>
+ <keyword name="sigc::signal4::result_type" link="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0" type="typedef"/>
+ <keyword name="sigc::signal4::reverse_iterator" link="classsigc_1_1signal4.html#a1395da7d3283b0166af135193a4047c8" type="typedef"/>
+ <keyword name="sigc::signal4::slot_list_type" link="classsigc_1_1signal4.html#a0ad0f56a43825c6d77d36dd2f06ef828" type="typedef"/>
+ <keyword name="sigc::signal4::slot_type" link="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c" type="typedef"/>
+ <keyword name="sigc::signal4::signal4" link="classsigc_1_1signal4.html#a2d469f516a9edac2b20d7f6cf46e821a" type="function"/>
+ <keyword name="sigc::signal4::signal4" link="classsigc_1_1signal4.html#a2d29b39c12c6c014ed7166190e9c8e22" type="function"/>
+ <keyword name="sigc::signal4::signal4" link="classsigc_1_1signal4.html#a2197974bac2b5e8e7b1c417580686e9e" type="function"/>
+ <keyword name="sigc::signal4::connect" link="classsigc_1_1signal4.html#a5fdb6df3cf74f5c96fb6319eef4d0a39" type="function"/>
+ <keyword name="sigc::signal4::connect" link="classsigc_1_1signal4.html#a5c8d2d9c91a134650a52631d49ecdaac" type="function"/>
+ <keyword name="sigc::signal4::emit" link="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef" type="function"/>
+ <keyword name="sigc::signal4::emit_reverse" link="classsigc_1_1signal4.html#a0aaf27875cdb8a0ae381372d98871ae1" type="function"/>
+ <keyword name="sigc::signal4::make_slot" link="classsigc_1_1signal4.html#aebcf1389e689b8d43ff739df118482bc" type="function"/>
+ <keyword name="sigc::signal4::operator()" link="classsigc_1_1signal4.html#a8523a4d47c3a6469fcc50da9977afdb8" type="function"/>
+ <keyword name="sigc::signal4::operator=" link="classsigc_1_1signal4.html#a05908db9c09a9c513529cd8b2106f913" type="function"/>
+ <keyword name="sigc::signal4::operator=" link="classsigc_1_1signal4.html#ab21da01af7c724bf0cf9df35ee9a70c1" type="function"/>
+ <keyword name="sigc::signal4::slots" link="classsigc_1_1signal4.html#ae490f1a6802c40a4c3b12e1580520c88" type="function"/>
+ <keyword name="sigc::signal4::slots" link="classsigc_1_1signal4.html#a35f2cebe3804d3e04d3253b7cc8d2a72" type="function"/>
+ <keyword type="struct" name="sigc::signal5" link="classsigc_1_1signal5.html"/>
+ <keyword name="sigc::signal5::const_iterator" link="classsigc_1_1signal5.html#a17e79eed46f178a12d2751eddcf85290" type="typedef"/>
+ <keyword name="sigc::signal5::const_reverse_iterator" link="classsigc_1_1signal5.html#ad5ba46907fe236e0cff806888696d569" type="typedef"/>
+ <keyword name="sigc::signal5::emitter_type" link="classsigc_1_1signal5.html#a7d77e5fa748b024842bf92e28cf0f4ab" type="typedef"/>
+ <keyword name="sigc::signal5::iterator" link="classsigc_1_1signal5.html#acee689b441305fcee098345729fc28f3" type="typedef"/>
+ <keyword name="sigc::signal5::result_type" link="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94" type="typedef"/>
+ <keyword name="sigc::signal5::reverse_iterator" link="classsigc_1_1signal5.html#ab684cb9920d0f7949f28c03d50b58275" type="typedef"/>
+ <keyword name="sigc::signal5::slot_list_type" link="classsigc_1_1signal5.html#a4c79ab227fc3b31b990e925636f7788e" type="typedef"/>
+ <keyword name="sigc::signal5::slot_type" link="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e" type="typedef"/>
+ <keyword name="sigc::signal5::signal5" link="classsigc_1_1signal5.html#af717d1a6fd8612da84dce33fe6640b7a" type="function"/>
+ <keyword name="sigc::signal5::signal5" link="classsigc_1_1signal5.html#a7885861b9cdbacbe2d58a13cd96ec265" type="function"/>
+ <keyword name="sigc::signal5::signal5" link="classsigc_1_1signal5.html#af39141aeec9dc870dd28926202493de4" type="function"/>
+ <keyword name="sigc::signal5::connect" link="classsigc_1_1signal5.html#a057789cc27a920700e240f8f3d78dd65" type="function"/>
+ <keyword name="sigc::signal5::connect" link="classsigc_1_1signal5.html#a05cfed3d3e29158424bc810168d78153" type="function"/>
+ <keyword name="sigc::signal5::emit" link="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" type="function"/>
+ <keyword name="sigc::signal5::emit_reverse" link="classsigc_1_1signal5.html#aa6d2e202263e3879f0d3949612d7fcdf" type="function"/>
+ <keyword name="sigc::signal5::make_slot" link="classsigc_1_1signal5.html#a7b01481c87d4ec9c03095e76cb502c24" type="function"/>
+ <keyword name="sigc::signal5::operator()" link="classsigc_1_1signal5.html#a7a5bb7b92f49e99354caf50bfef16907" type="function"/>
+ <keyword name="sigc::signal5::operator=" link="classsigc_1_1signal5.html#a2c3d9a6d8b499da389672f44f8044ce6" type="function"/>
+ <keyword name="sigc::signal5::operator=" link="classsigc_1_1signal5.html#a5c652f8e549a2c555b79db8e8a05f407" type="function"/>
+ <keyword name="sigc::signal5::slots" link="classsigc_1_1signal5.html#ad6a4ae2a214d8710be6e36bb425587fc" type="function"/>
+ <keyword name="sigc::signal5::slots" link="classsigc_1_1signal5.html#a32af276c9c56abbb0386f54262b40be5" type="function"/>
+ <keyword type="struct" name="sigc::signal6" link="classsigc_1_1signal6.html"/>
+ <keyword name="sigc::signal6::const_iterator" link="classsigc_1_1signal6.html#ac88a9c4e9bab5ad04c66d3f5d3978f0f" type="typedef"/>
+ <keyword name="sigc::signal6::const_reverse_iterator" link="classsigc_1_1signal6.html#aff490e7f75a83aa2f324a859f9071a79" type="typedef"/>
+ <keyword name="sigc::signal6::emitter_type" link="classsigc_1_1signal6.html#acdd2683223e4701f58350152f32f4488" type="typedef"/>
+ <keyword name="sigc::signal6::iterator" link="classsigc_1_1signal6.html#a1acee11287974cdac1bc63c856e5331d" type="typedef"/>
+ <keyword name="sigc::signal6::result_type" link="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f" type="typedef"/>
+ <keyword name="sigc::signal6::reverse_iterator" link="classsigc_1_1signal6.html#a79b741b3f0def8f52fc185ad50b60673" type="typedef"/>
+ <keyword name="sigc::signal6::slot_list_type" link="classsigc_1_1signal6.html#a0e4fea9bd1ed35f9d60bbc26c4fae007" type="typedef"/>
+ <keyword name="sigc::signal6::slot_type" link="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db" type="typedef"/>
+ <keyword name="sigc::signal6::signal6" link="classsigc_1_1signal6.html#af7f529bbd9cf26d468ed18426b9b51ea" type="function"/>
+ <keyword name="sigc::signal6::signal6" link="classsigc_1_1signal6.html#a0244dde296bd892c590c86ced5281e3b" type="function"/>
+ <keyword name="sigc::signal6::signal6" link="classsigc_1_1signal6.html#ab717ce413bda79e1de41944d0675a8ca" type="function"/>
+ <keyword name="sigc::signal6::connect" link="classsigc_1_1signal6.html#a66c302607cf4fb74f5d3352f9c394c9b" type="function"/>
+ <keyword name="sigc::signal6::connect" link="classsigc_1_1signal6.html#a1754aa5a8959da0bb55e42864a8365af" type="function"/>
+ <keyword name="sigc::signal6::emit" link="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" type="function"/>
+ <keyword name="sigc::signal6::emit_reverse" link="classsigc_1_1signal6.html#a2e8b355902f0646fb34b52b495123167" type="function"/>
+ <keyword name="sigc::signal6::make_slot" link="classsigc_1_1signal6.html#a97ae4180e80ac60b564fec58d1732317" type="function"/>
+ <keyword name="sigc::signal6::operator()" link="classsigc_1_1signal6.html#affec011fd6e9605f10e50fdd4db424d8" type="function"/>
+ <keyword name="sigc::signal6::operator=" link="classsigc_1_1signal6.html#ad7a4ab249b17bffccbfe441aa1420dd9" type="function"/>
+ <keyword name="sigc::signal6::operator=" link="classsigc_1_1signal6.html#a012b9abce888e420e1b5b3f29aa98900" type="function"/>
+ <keyword name="sigc::signal6::slots" link="classsigc_1_1signal6.html#af44115a7bfa4586fc5312259a1df9567" type="function"/>
+ <keyword name="sigc::signal6::slots" link="classsigc_1_1signal6.html#ac66109f683ae86898ae10109a80b28a4" type="function"/>
+ <keyword type="struct" name="sigc::signal7" link="classsigc_1_1signal7.html"/>
+ <keyword name="sigc::signal7::const_iterator" link="classsigc_1_1signal7.html#a6eef6225eba66a86dd32c3f3b79845f7" type="typedef"/>
+ <keyword name="sigc::signal7::const_reverse_iterator" link="classsigc_1_1signal7.html#ad1ba32ad7dae0c05a4012ada78077505" type="typedef"/>
+ <keyword name="sigc::signal7::emitter_type" link="classsigc_1_1signal7.html#a7fa856e67a31c86538db7c289a6870e3" type="typedef"/>
+ <keyword name="sigc::signal7::iterator" link="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a" type="typedef"/>
+ <keyword name="sigc::signal7::result_type" link="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f" type="typedef"/>
+ <keyword name="sigc::signal7::reverse_iterator" link="classsigc_1_1signal7.html#a59c9c9fee7a98528839df592241351a9" type="typedef"/>
+ <keyword name="sigc::signal7::slot_list_type" link="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003" type="typedef"/>
+ <keyword name="sigc::signal7::slot_type" link="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81" type="typedef"/>
+ <keyword name="sigc::signal7::signal7" link="classsigc_1_1signal7.html#ab6d54db53a164fb459fcb342d4b45ff0" type="function"/>
+ <keyword name="sigc::signal7::signal7" link="classsigc_1_1signal7.html#a12d6e064d0a5c2a8c09d60a64184a823" type="function"/>
+ <keyword name="sigc::signal7::signal7" link="classsigc_1_1signal7.html#a5a5893dd4f97d77b7945819f5ada2aee" type="function"/>
+ <keyword name="sigc::signal7::connect" link="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2" type="function"/>
+ <keyword name="sigc::signal7::connect" link="classsigc_1_1signal7.html#a5aed4bdb8d85c3d854f01410d2d9d3a4" type="function"/>
+ <keyword name="sigc::signal7::emit" link="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" type="function"/>
+ <keyword name="sigc::signal7::emit_reverse" link="classsigc_1_1signal7.html#a192581feb2dbcfc9c56692e72e91e9a8" type="function"/>
+ <keyword name="sigc::signal7::make_slot" link="classsigc_1_1signal7.html#a3f468c8b6cc55d675c75d0184bd8e38a" type="function"/>
+ <keyword name="sigc::signal7::operator()" link="classsigc_1_1signal7.html#ac6fd43215c8f19082402387359330071" type="function"/>
+ <keyword name="sigc::signal7::operator=" link="classsigc_1_1signal7.html#af8a93a4c8fb0b78fa6578e7dc95f5751" type="function"/>
+ <keyword name="sigc::signal7::operator=" link="classsigc_1_1signal7.html#ac06938f5cb6ff60a1bd5eaa32c990eea" type="function"/>
+ <keyword name="sigc::signal7::slots" link="classsigc_1_1signal7.html#a68153d9079b4881352113079cd6216f7" type="function"/>
+ <keyword name="sigc::signal7::slots" link="classsigc_1_1signal7.html#a42509108239296e424844df2cd330aca" type="function"/>
+ <keyword type="struct" name="sigc::signal::accumulated" link="classsigc_1_1signal_1_1accumulated.html"/>
+ <keyword name="sigc::signal::accumulated::accumulated" link="classsigc_1_1signal_1_1accumulated.html#a46bed3515606e0a5807f08e239891ca0" type="function"/>
+ <keyword name="sigc::signal::accumulated::accumulated" link="classsigc_1_1signal_1_1accumulated.html#a032428476a190d9dea6313f70e5b8a10" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return()>" link="classsigc_1_1signal_3_01T__return_07_08_4.html"/>
+ <keyword name="sigc::signal< T_return()>::signal" link="classsigc_1_1signal_3_01T__return_07_08_4.html#aefdfdd54adc65612b58929298274453c" type="function"/>
+ <keyword name="sigc::signal< T_return()>::signal" link="classsigc_1_1signal_3_01T__return_07_08_4.html#aba571147db7b805fad8da3c0c82fea0b" type="function"/>
+ <keyword name="sigc::signal< T_return()>::signal" link="classsigc_1_1signal_3_01T__return_07_08_4.html#a2656448f8eb3cf4d9043009f56b08104" type="function"/>
+ <keyword name="sigc::signal< T_return()>::operator=" link="classsigc_1_1signal_3_01T__return_07_08_4.html#acbc101f4d7b4e460929593bac336957f" type="function"/>
+ <keyword name="sigc::signal< T_return()>::operator=" link="classsigc_1_1signal_3_01T__return_07_08_4.html#a8dd6b8bd581d87858007484d62347484" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return()>::accumulated" link="classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html"/>
+ <keyword name="sigc::signal< T_return()>::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html#a601feadb67ac4aaa7af709af51f654ca" type="function"/>
+ <keyword name="sigc::signal< T_return()>::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html#a219dd919cd64e95ad89c5a501b3abcf6" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return(T_arg1)>" link="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html"/>
+ <keyword name="sigc::signal< T_return(T_arg1)>::signal" link="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html#a2e6e6d55741d1ef7e4ef3cf1a385ccf1" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1)>::signal" link="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html#a41a5c99993530756404583e4fbc748ba" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1)>::signal" link="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html#acc30f0949e699fbff85d341162298761" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1)>::operator=" link="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html#a20f539ef645cba235c03d8d13f221ae5" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1)>::operator=" link="classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html#a1014db39eed6f085ab79116510005e4c" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return(T_arg1)>::accumulated" link="classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html"/>
+ <keyword name="sigc::signal< T_return(T_arg1)>::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html#a31b87e65e2e6be201c18ff7c7c3e87e9" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1)>::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html#abbb5481dc26b9efce3b8604eb0f6ea27" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return(T_arg1, T_arg2)>" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2)>::signal" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html#a9d8fa2e7dd971a359c53c5ed19310f00" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2)>::signal" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html#a13d95a6b3058ddbd0f55fd00953cdee5" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2)>::signal" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html#acc41707d3187fe1ac6bb9180f82428a7" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2)>::operator=" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html#abdcf63e52e05fd88654a7e688abd57b1" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2)>::operator=" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html#a925adc69603e7caab05920baf7f80faf" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return(T_arg1, T_arg2)>::accumulated" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2)>::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html#abf5d54ba4c8e7f2792be010df45df59b" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2)>::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html#af6082d36c41f676b54f271f31ca781b6" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3)>" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3)>::signal" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html#a27d493742451c292a6c001b9353c08d9" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3)>::signal" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html#a51bd913df6a849d6dd720e8c19532149" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3)>::signal" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html#ac22b59e41db40b6cbe6ac4b71d048170" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3)>::operator=" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html#a43ee800d35a162d99893f6a55f5a7c72" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3)>::operator=" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html#aee5b61e3b98fe989e78f96d2117d74d1" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3)>::accumulated" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3)>::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html#a096e447ba082bebd28601309d595807c" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3)>::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html#ad47d6448e3137d45649656d23b19f89a" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::signal" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html#a1569f4348e140681f696a49028309042" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::signal" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html#a435444e5772da8ddb74edb7f901f3ae6" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::signal" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html#a8d26e7db0ca474d71736c778e0264f4c" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::operator=" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html#a838a70902714d4cb065ea1bf22e0f376" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::operator=" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html#abeda698e53b2b9b3bd9e5aa91f02abfd" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::accumulated" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html#acd7fd012dcc073e9a6770af949517040" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html#a3197013a55f3afc0fb9451b033c3fe47" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::signal" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html#a7006442d66ee8f812ffdff15cd5694a3" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::signal" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html#a7d61f31c6577339602b629bff20f0248" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::signal" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html#a016fcefe1eb805926dafad10f970f826" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::operator=" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html#ac3fd7b8ac2caf93330629a3caa000d57" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::operator=" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html#a95b7d55776c477cae58859f01a043d6e" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::accumulated" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html#a77a966e973f4ab159f0dbb92737dd02e" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html#a3b820b8e12b845648ff1eeff72bf97fa" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::signal" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html#a6ec07b9037eeeab8094beb440d80407b" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::signal" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html#a975a2a33c137e6b662a31933d80563d6" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::signal" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html#a16f865ba75270a1808ed8f3a37e53a48" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::operator=" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html#ad93fa9a04fa76e3133adb4361981c5cd" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::operator=" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html#a249b8264efb4167bf468a6b4c01fe6b5" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::accumulated" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html#a3daa5943f5b629a17a547b75743b8829" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html#afe1cea16b0f0296ff874a2793cc51b53" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::signal" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html#ac3cad4e400bacfc4a539cb7a31cd0e01" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::signal" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html#a9b9928bf9b40cae47599be1f4f7f85dc" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::signal" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html#a5595334118f67137ded1af1720743da8" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::operator=" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html#a8fe96aaacf6a2d0780887623a6f2b15a" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::operator=" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html#aaa92f0fe77bca0af86a3a0ddd77bc96b" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::accumulated" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html#a33552c46e4db86b98bea128fd32d2c08" type="function"/>
+ <keyword name="sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html#afc104f4e3d7a445cf4f7989c52f1d93c" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil >" link="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html"/>
+ <keyword name="sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil >::signal" link="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a69bd320a61ade13046ae3ed20498ab83" type="function"/>
+ <keyword name="sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil >::signal" link="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a3dcbc7a6481f46f08a366e489876a7a0" type="function"/>
+ <keyword name="sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil >::signal" link="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a59107d243fe3408d64e4e963d5023dcb" type="function"/>
+ <keyword name="sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil >::operator=" link="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a9603080b1a0c76e32eb6859594c59665" type="function"/>
+ <keyword name="sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil >::operator=" link="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a08ac3766c65bb61177b49a62667a5a53" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil >::accumulated" link="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html"/>
+ <keyword name="sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil >::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#a54763bd7352a9c84b5e5956b4f65c914" type="function"/>
+ <keyword name="sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil >::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#a1cea5890a6ac54f475ae28062c99e4f4" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html"/>
+ <keyword name="sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::signal" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a7561df6caf1f508eff71f035db8260c1" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::signal" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ae55caf393287987076a093a17cd2a272" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::signal" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#aee2249d4e36771d4f2d5f6c8848a95ce" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::operator=" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a418026bd364a6b5510f0227f497b9473" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::operator=" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ac10afd98d20258707f8748f4af3063d9" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::accumulated" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html"/>
+ <keyword name="sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#a772b7939dc0552087c6b52a98d97eab8" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#a94b30a9ffefefc43cb79b4f30ad65237" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::signal" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a3ad9be2894fd3f78bfde9488207ff502" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::signal" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a199611dacb9e03614c9203ad27597667" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::signal" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ae7f76745ea92595cdd179725425487ea" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::operator=" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a3baee6b97500078ea6297959e1f9ca9c" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::operator=" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ab610351f5cdf9f332d9a1003a0481ab3" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::accumulated" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#a83f917545362d71b7d08fee23e619eaf" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html#aa462577f7f52f54b2bf2c87cbb7aa9bc" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::signal" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a3866d625025ecae063d59e81f86ec836" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::signal" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a80e31f482db26fc380264b7dea1041d7" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::signal" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a84d26ae312afec80b6a921894a52e9a8" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::operator=" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a706478aa21230e1b6ff4347f87efb0dc" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::operator=" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a8a0166f439840b854ab3253fa831bb03" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::accumulated" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html#a86aae36f669ce2f9d7f1f0ac9a696f6c" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html#ab20d2ddd7330aa974d61ddec753413b6" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::signal" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a76731fb4092ef8d9b459c8c32c5433dc" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::signal" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a299bbe1b511723c6c854e516aaf0a926" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::signal" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a51f9443b48b006a65114bdd18d13cd4b" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::operator=" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a84ee7d648bf622ec496127ceec819946" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::operator=" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a7e84970efac0339e7ebaaa46540ef0cc" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::accumulated" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html#a994494b04443cda13eef81e13321db83" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html#a2d21852efcef1d59cc96c8c873e6ce37" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::signal" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a5e64ba037f3567ab5dbb49811a447b2c" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::signal" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a2f45d321526546618c56c1d5400507d2" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::signal" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a3447b5d32b839fa22ac7845ea448d2b4" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::operator=" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a4d6e1453a0b4284cc19996e36cff5eef" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::operator=" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a05a22fca63088154ba5c15b221e30760" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::accumulated" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html#a0b18943e223f1ae150ee5541673a2e29" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html#a3e41ce87d15bc90960abd857ca80aed9" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::signal" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a1dd1e779ef29d6df2b570847c4f2819e" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::signal" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#aa070e4d37a8a06ef9fc02256d236472c" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::signal" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a09609c04d7601601c9726aef1c74ecc7" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::operator=" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#ace9ebd1d47d825a1ee18ae0b2c639ab1" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::operator=" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a6cbe2b81b53c97bc39c26bbedcb070f1" type="function"/>
+ <keyword type="struct" name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::accumulated" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html#a0f2cc39e9f222a296072f8c05ad98796" type="function"/>
+ <keyword name="sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::accumulated::accumulated" link="classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html#a239f7a4fefc7cb2cc6c4fb6c9c332d2f" type="function"/>
+ <keyword type="struct" name="sigc::signal_base" link="structsigc_1_1signal__base.html"/>
+ <keyword name="sigc::signal_base::size_type" link="structsigc_1_1signal__base.html#aa60e22abd088b6cde2dd50fb3f228aa4" type="typedef"/>
+ <keyword name="sigc::signal_base::signal_base" link="structsigc_1_1signal__base.html#aff65198ddcb4fbccb644ff853e663e0e" type="function"/>
+ <keyword name="sigc::signal_base::signal_base" link="structsigc_1_1signal__base.html#a761e95b8c7b460664d3338ed3eb39543" type="function"/>
+ <keyword name="sigc::signal_base::signal_base" link="structsigc_1_1signal__base.html#a9f8570c89cd5c0b35613570a5ea80154" type="function"/>
+ <keyword name="sigc::signal_base::~signal_base" link="structsigc_1_1signal__base.html#afa2e5807537c989b430015e5ae05a357" type="function"/>
+ <keyword name="sigc::signal_base::block" link="structsigc_1_1signal__base.html#a52fda4806ec9dbc02baa95ce70c13fb0" type="function"/>
+ <keyword name="sigc::signal_base::blocked" link="structsigc_1_1signal__base.html#a228da4dd1eac6905dafbc5697086e503" type="function"/>
+ <keyword name="sigc::signal_base::clear" link="structsigc_1_1signal__base.html#a17597d66e680d222248c523985f0afd6" type="function"/>
+ <keyword name="sigc::signal_base::empty" link="structsigc_1_1signal__base.html#a24e7fc4e07ac19cebafe8e3bd71bfe94" type="function"/>
+ <keyword name="sigc::signal_base::operator=" link="structsigc_1_1signal__base.html#a90b36a7b33e107ce0af0de895e0df286" type="function"/>
+ <keyword name="sigc::signal_base::operator=" link="structsigc_1_1signal__base.html#a277a34edf44207fb4784807eac5872c6" type="function"/>
+ <keyword name="sigc::signal_base::size" link="structsigc_1_1signal__base.html#a0725416f747d6db3c57fa318a9f887a8" type="function"/>
+ <keyword name="sigc::signal_base::unblock" link="structsigc_1_1signal__base.html#aebb7ac69ea745cd60c0505f8d553d27f" type="function"/>
+ <keyword name="sigc::signal_base::iterator_type" link="structsigc_1_1signal__base.html#a328b132e5dfb99dbc3aae1e5c3bb0981" type="typedef"/>
+ <keyword name="sigc::signal_base::connect" link="structsigc_1_1signal__base.html#a5c89a76a27d69c512f554b841b1bd08a" type="function"/>
+ <keyword name="sigc::signal_base::connect" link="structsigc_1_1signal__base.html#a50eab6d37728bbbf3beb21d684a72e6c" type="function"/>
+ <keyword name="sigc::signal_base::erase" link="structsigc_1_1signal__base.html#a21efc57eea29c3139855909ad4807984" type="function"/>
+ <keyword name="sigc::signal_base::impl" link="structsigc_1_1signal__base.html#ab0527d817989f2386556ce164c3adfa7" type="function"/>
+ <keyword name="sigc::signal_base::insert" link="structsigc_1_1signal__base.html#a87da23ad801faa9e2b6b4be2a747e757" type="function"/>
+ <keyword name="sigc::signal_base::insert" link="structsigc_1_1signal__base.html#aa80c33868910139dd2f511afcc31b687" type="function"/>
+ <keyword type="struct" name="sigc::slot" link="classsigc_1_1slot.html"/>
+ <keyword name="sigc::slot::parent_type" link="classsigc_1_1slot.html#a1966941e9654adfb3af4b994fd18a7f3" type="typedef"/>
+ <keyword name="sigc::slot::slot" link="classsigc_1_1slot.html#af643a8ef3eafd24f738224bbd6056fa3" type="function"/>
+ <keyword name="sigc::slot::slot" link="classsigc_1_1slot.html#ac53122c7f0f1f4dd9493e9ac88837ae2" type="function"/>
+ <keyword name="sigc::slot::slot" link="classsigc_1_1slot.html#ad790b9eb2c959f0f266dc94c0e84dd35" type="function"/>
+ <keyword name="sigc::slot::slot" link="classsigc_1_1slot.html#a445f8243e1eac20f8f925824c4acf4cf" type="function"/>
+ <keyword name="sigc::slot::operator=" link="classsigc_1_1slot.html#ac7beb1ab973b6cd124d2cdea3f0c1e0c" type="function"/>
+ <keyword name="sigc::slot::operator=" link="classsigc_1_1slot.html#a0f4ef3f59a7f7228b8b4fddabdbd6924" type="function"/>
+ <keyword type="struct" name="sigc::slot0" link="classsigc_1_1slot0.html"/>
+ <keyword name="sigc::slot0::result_type" link="classsigc_1_1slot0.html#aca0c967b605e09d5a87015d95e93d4f7" type="typedef"/>
+ <keyword name="sigc::slot0::slot0" link="classsigc_1_1slot0.html#a8681082ecd439d5b294922e4d27a3f49" type="function"/>
+ <keyword name="sigc::slot0::slot0" link="classsigc_1_1slot0.html#acce9a5d9a4f939e405383092ba717f72" type="function"/>
+ <keyword name="sigc::slot0::slot0" link="classsigc_1_1slot0.html#a83a247c06b93ef644bdfe0bf119929c0" type="function"/>
+ <keyword name="sigc::slot0::slot0" link="classsigc_1_1slot0.html#ac93b53e3d90df14b2b003ad0c685b160" type="function"/>
+ <keyword name="sigc::slot0::operator()" link="classsigc_1_1slot0.html#afa926436a4b0734f0adc2a485ccfe36a" type="function"/>
+ <keyword name="sigc::slot0::operator=" link="classsigc_1_1slot0.html#a49bba0540dcc76fb19e49d19a1acd563" type="function"/>
+ <keyword name="sigc::slot0::operator=" link="classsigc_1_1slot0.html#a95205051379e5d5657bac78c9b3b8d49" type="function"/>
+ <keyword type="struct" name="sigc::slot1" link="classsigc_1_1slot1.html"/>
+ <keyword name="sigc::slot1::arg1_type_" link="classsigc_1_1slot1.html#a4d81838957a9ccc6cb4c104706a37a89" type="typedef"/>
+ <keyword name="sigc::slot1::result_type" link="classsigc_1_1slot1.html#ab4991fe5d80761ddab482fda9ebe6d17" type="typedef"/>
+ <keyword name="sigc::slot1::slot1" link="classsigc_1_1slot1.html#aa8ac5eadba778c11a424e255889e67f6" type="function"/>
+ <keyword name="sigc::slot1::slot1" link="classsigc_1_1slot1.html#ac6ecaff0a20a57d2168ea126e565e36a" type="function"/>
+ <keyword name="sigc::slot1::slot1" link="classsigc_1_1slot1.html#a20999708c6db16a3015beca7d4ad866e" type="function"/>
+ <keyword name="sigc::slot1::slot1" link="classsigc_1_1slot1.html#a4ab8f18f97f843558f11adb9d1e8e478" type="function"/>
+ <keyword name="sigc::slot1::operator()" link="classsigc_1_1slot1.html#ae9082daf31fdbb57da71e8c38a9ae1ab" type="function"/>
+ <keyword name="sigc::slot1::operator=" link="classsigc_1_1slot1.html#a2e0d65cfc434718b6c5f7d7135ac384e" type="function"/>
+ <keyword name="sigc::slot1::operator=" link="classsigc_1_1slot1.html#a195acd57b42149a2faaeec4c6725825a" type="function"/>
+ <keyword type="struct" name="sigc::slot2" link="classsigc_1_1slot2.html"/>
+ <keyword name="sigc::slot2::arg1_type_" link="classsigc_1_1slot2.html#ae69b03a4119d61a0a521b0ad5ddaae46" type="typedef"/>
+ <keyword name="sigc::slot2::arg2_type_" link="classsigc_1_1slot2.html#af03b1377bbfcdc742a7c00f4c2c419f7" type="typedef"/>
+ <keyword name="sigc::slot2::result_type" link="classsigc_1_1slot2.html#a0bb920e3d5628c3d01a4337a2a8a97fc" type="typedef"/>
+ <keyword name="sigc::slot2::slot2" link="classsigc_1_1slot2.html#a3f9f6cf199bbb40011eca25eb9da67c2" type="function"/>
+ <keyword name="sigc::slot2::slot2" link="classsigc_1_1slot2.html#a868deef9d947dfa4fcbb0cfe64cbd42e" type="function"/>
+ <keyword name="sigc::slot2::slot2" link="classsigc_1_1slot2.html#a14641110a8fdbb060a58c037b9000730" type="function"/>
+ <keyword name="sigc::slot2::slot2" link="classsigc_1_1slot2.html#a4719ba9494f87e682b6a6d04b02413e7" type="function"/>
+ <keyword name="sigc::slot2::operator()" link="classsigc_1_1slot2.html#aa2abda2a910db19bbb7a2a08d867e358" type="function"/>
+ <keyword name="sigc::slot2::operator=" link="classsigc_1_1slot2.html#a6b3d5de4d2e7a6134cc883b98380caa7" type="function"/>
+ <keyword name="sigc::slot2::operator=" link="classsigc_1_1slot2.html#aeda5a84c674376aa0800a0bf876bb5fa" type="function"/>
+ <keyword type="struct" name="sigc::slot3" link="classsigc_1_1slot3.html"/>
+ <keyword name="sigc::slot3::arg1_type_" link="classsigc_1_1slot3.html#ac6791fffc805aa2303713fea377dbaae" type="typedef"/>
+ <keyword name="sigc::slot3::arg2_type_" link="classsigc_1_1slot3.html#a7390ac1945e87a1e0d172fe266a58d72" type="typedef"/>
+ <keyword name="sigc::slot3::arg3_type_" link="classsigc_1_1slot3.html#a54a09bfe0dd9c518ec22cc14a7e43a23" type="typedef"/>
+ <keyword name="sigc::slot3::result_type" link="classsigc_1_1slot3.html#a69cca26f164c63de6ffa70a3806fb936" type="typedef"/>
+ <keyword name="sigc::slot3::slot3" link="classsigc_1_1slot3.html#ac477d74beed45b2b3e26d19b083147ad" type="function"/>
+ <keyword name="sigc::slot3::slot3" link="classsigc_1_1slot3.html#afa87acf0475e178f8d970bf05f84b04b" type="function"/>
+ <keyword name="sigc::slot3::slot3" link="classsigc_1_1slot3.html#aeb40907cf0589e97fd541c71e368ad03" type="function"/>
+ <keyword name="sigc::slot3::slot3" link="classsigc_1_1slot3.html#a74644090c829923a4dda5e09f932d4f9" type="function"/>
+ <keyword name="sigc::slot3::operator()" link="classsigc_1_1slot3.html#addbe340b1f547308035707236e690e66" type="function"/>
+ <keyword name="sigc::slot3::operator=" link="classsigc_1_1slot3.html#a2ff8f9202019d25ddab688128c504e72" type="function"/>
+ <keyword name="sigc::slot3::operator=" link="classsigc_1_1slot3.html#ac40a1cefaf9c356a691dfea6819094b8" type="function"/>
+ <keyword type="struct" name="sigc::slot4" link="classsigc_1_1slot4.html"/>
+ <keyword name="sigc::slot4::arg1_type_" link="classsigc_1_1slot4.html#a4426d0dcf517d0d815d6add3c9490437" type="typedef"/>
+ <keyword name="sigc::slot4::arg2_type_" link="classsigc_1_1slot4.html#abf1d276525f0120a734b2b054b9cfb3f" type="typedef"/>
+ <keyword name="sigc::slot4::arg3_type_" link="classsigc_1_1slot4.html#ae1af3fbe3981779b68f5676f46f6085c" type="typedef"/>
+ <keyword name="sigc::slot4::arg4_type_" link="classsigc_1_1slot4.html#aec7f4747dbe5b581c65c07033ca1bfe5" type="typedef"/>
+ <keyword name="sigc::slot4::result_type" link="classsigc_1_1slot4.html#a3f6b5b11385536c1c199ca29468c638a" type="typedef"/>
+ <keyword name="sigc::slot4::slot4" link="classsigc_1_1slot4.html#a4b8ef0494eea86c0d787486ce121db91" type="function"/>
+ <keyword name="sigc::slot4::slot4" link="classsigc_1_1slot4.html#a7b7080168e769cdec8d916f71fa58d21" type="function"/>
+ <keyword name="sigc::slot4::slot4" link="classsigc_1_1slot4.html#a50d331d378ba1f3cb03f39a42a4aa3cf" type="function"/>
+ <keyword name="sigc::slot4::slot4" link="classsigc_1_1slot4.html#acf9e9b169fddb40079618f870172f535" type="function"/>
+ <keyword name="sigc::slot4::operator()" link="classsigc_1_1slot4.html#a02b0d861a47418b9dbf73ab7db67b0a9" type="function"/>
+ <keyword name="sigc::slot4::operator=" link="classsigc_1_1slot4.html#ac2fb7f8ae312ced5b7436f0a0d062132" type="function"/>
+ <keyword name="sigc::slot4::operator=" link="classsigc_1_1slot4.html#ad05b8c996262ab1bcac89d8c8004a0b5" type="function"/>
+ <keyword type="struct" name="sigc::slot5" link="classsigc_1_1slot5.html"/>
+ <keyword name="sigc::slot5::arg1_type_" link="classsigc_1_1slot5.html#aeda4706cbac7cb87a276ffeb8bdada16" type="typedef"/>
+ <keyword name="sigc::slot5::arg2_type_" link="classsigc_1_1slot5.html#ad93d2b3cdce1c3990bde0f49693096e1" type="typedef"/>
+ <keyword name="sigc::slot5::arg3_type_" link="classsigc_1_1slot5.html#aab17d4f2a38e02219c1a4757ba268baf" type="typedef"/>
+ <keyword name="sigc::slot5::arg4_type_" link="classsigc_1_1slot5.html#afe7fd46dc4b01397db2c2a9c70b02735" type="typedef"/>
+ <keyword name="sigc::slot5::arg5_type_" link="classsigc_1_1slot5.html#ade67aef04bbfd7c6af63e93afc709321" type="typedef"/>
+ <keyword name="sigc::slot5::result_type" link="classsigc_1_1slot5.html#aac50a6486dddcac3a42022a6f2189f09" type="typedef"/>
+ <keyword name="sigc::slot5::slot5" link="classsigc_1_1slot5.html#a7548f0d175acd8296064c9bc6d76ea88" type="function"/>
+ <keyword name="sigc::slot5::slot5" link="classsigc_1_1slot5.html#ad54fd2ef5f50844c214f1a5fbaef9299" type="function"/>
+ <keyword name="sigc::slot5::slot5" link="classsigc_1_1slot5.html#abcf315edb57a1a23ab7f4a0d25e57736" type="function"/>
+ <keyword name="sigc::slot5::slot5" link="classsigc_1_1slot5.html#a9c7dc2f187084d174ea9f834178d491d" type="function"/>
+ <keyword name="sigc::slot5::operator()" link="classsigc_1_1slot5.html#a3f2d9fa2c9747d6c7fc329213446c71d" type="function"/>
+ <keyword name="sigc::slot5::operator=" link="classsigc_1_1slot5.html#a24d22be7be827080b34109c625bad7fd" type="function"/>
+ <keyword name="sigc::slot5::operator=" link="classsigc_1_1slot5.html#af000284699d7f5594599f6e742f64e4a" type="function"/>
+ <keyword type="struct" name="sigc::slot6" link="classsigc_1_1slot6.html"/>
+ <keyword name="sigc::slot6::arg1_type_" link="classsigc_1_1slot6.html#a98240591834da17569f94410684120ba" type="typedef"/>
+ <keyword name="sigc::slot6::arg2_type_" link="classsigc_1_1slot6.html#a44b34c5068d0150922cc630400a1962a" type="typedef"/>
+ <keyword name="sigc::slot6::arg3_type_" link="classsigc_1_1slot6.html#a05f153d441986f23d115bf29c92736ca" type="typedef"/>
+ <keyword name="sigc::slot6::arg4_type_" link="classsigc_1_1slot6.html#a285a8d86913eff1b27b89f4d795190c1" type="typedef"/>
+ <keyword name="sigc::slot6::arg5_type_" link="classsigc_1_1slot6.html#a4a304a22b1a1fae56b7998ae4ae3c0e1" type="typedef"/>
+ <keyword name="sigc::slot6::arg6_type_" link="classsigc_1_1slot6.html#ae935d9ad4042e4cfb0730e2855d7882e" type="typedef"/>
+ <keyword name="sigc::slot6::result_type" link="classsigc_1_1slot6.html#a8dae48d6160e0f917f545eb10950a9bf" type="typedef"/>
+ <keyword name="sigc::slot6::slot6" link="classsigc_1_1slot6.html#a3c763adcaa8b9c34c808ef0f15b1fc48" type="function"/>
+ <keyword name="sigc::slot6::slot6" link="classsigc_1_1slot6.html#a7e4c0f209961d3797f6fadfe9d1c6078" type="function"/>
+ <keyword name="sigc::slot6::slot6" link="classsigc_1_1slot6.html#a7458f98cd4ed4a9aa6671ea9f0c260f2" type="function"/>
+ <keyword name="sigc::slot6::slot6" link="classsigc_1_1slot6.html#af7132887ca029e0325d46baa2026bea4" type="function"/>
+ <keyword name="sigc::slot6::operator()" link="classsigc_1_1slot6.html#ac2d6449f2928138c434c474050c7c192" type="function"/>
+ <keyword name="sigc::slot6::operator=" link="classsigc_1_1slot6.html#a7d13ed520a19d287719bd24050b7d8a2" type="function"/>
+ <keyword name="sigc::slot6::operator=" link="classsigc_1_1slot6.html#a078ab12d6b08bd132041b4787f99ea85" type="function"/>
+ <keyword type="struct" name="sigc::slot7" link="classsigc_1_1slot7.html"/>
+ <keyword name="sigc::slot7::arg1_type_" link="classsigc_1_1slot7.html#a58edf93a837003d1a69fc77d39fc11a9" type="typedef"/>
+ <keyword name="sigc::slot7::arg2_type_" link="classsigc_1_1slot7.html#ad144d8ea3ecb891d358b5b1b969be7e2" type="typedef"/>
+ <keyword name="sigc::slot7::arg3_type_" link="classsigc_1_1slot7.html#af90cd5954008a84d6459d99de152a08c" type="typedef"/>
+ <keyword name="sigc::slot7::arg4_type_" link="classsigc_1_1slot7.html#af42bc9af248b7c2226d93230bd7b1024" type="typedef"/>
+ <keyword name="sigc::slot7::arg5_type_" link="classsigc_1_1slot7.html#ad6c1006a29f6fcb721bc39e8d6f82323" type="typedef"/>
+ <keyword name="sigc::slot7::arg6_type_" link="classsigc_1_1slot7.html#ae25a8a8663addfce52415a20725a3b3e" type="typedef"/>
+ <keyword name="sigc::slot7::arg7_type_" link="classsigc_1_1slot7.html#a2dc6c96b8d014fab9daea823188ca021" type="typedef"/>
+ <keyword name="sigc::slot7::result_type" link="classsigc_1_1slot7.html#a06a374d3304636cb48fed29542dc851f" type="typedef"/>
+ <keyword name="sigc::slot7::slot7" link="classsigc_1_1slot7.html#abf200ae4152fb26fc96a6863be3548b8" type="function"/>
+ <keyword name="sigc::slot7::slot7" link="classsigc_1_1slot7.html#a6411349bb6f8d7151f41ae7772e61f6d" type="function"/>
+ <keyword name="sigc::slot7::slot7" link="classsigc_1_1slot7.html#aa9b64dc6516b8a0d55f46e4737eaaf8b" type="function"/>
+ <keyword name="sigc::slot7::slot7" link="classsigc_1_1slot7.html#a69a267bb61931f4ea039048d3221517c" type="function"/>
+ <keyword name="sigc::slot7::operator()" link="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d" type="function"/>
+ <keyword name="sigc::slot7::operator=" link="classsigc_1_1slot7.html#af6bf09a0b3c09245257af113e70269d2" type="function"/>
+ <keyword name="sigc::slot7::operator=" link="classsigc_1_1slot7.html#a82b499c48909c51c4dad097885804638" type="function"/>
+ <keyword type="struct" name="sigc::slot< T_return(T_arg...)>" link="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html"/>
+ <keyword name="sigc::slot< T_return(T_arg...)>::result_type" link="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#af593e79280c004b6ef8f4722953df0c4" type="typedef"/>
+ <keyword name="sigc::slot< T_return(T_arg...)>::slot" link="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#add0d65ea6dc554733e766b3510c89a3a" type="function"/>
+ <keyword name="sigc::slot< T_return(T_arg...)>::slot" link="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#ad1e5bc73a259ee666eb8d11d9e48d1d7" type="function"/>
+ <keyword name="sigc::slot< T_return(T_arg...)>::slot" link="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#a8c7a2fb604a0a9495bfa2850bb3520f5" type="function"/>
+ <keyword name="sigc::slot< T_return(T_arg...)>::slot" link="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#ae7d852d9ac2c9a6a37564a0f4aed3872" type="function"/>
+ <keyword name="sigc::slot< T_return(T_arg...)>::operator()" link="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#a4038d1a1c7a34bbb344b61a8f43c23f6" type="function"/>
+ <keyword name="sigc::slot< T_return(T_arg...)>::operator=" link="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#a34e1ec92ebbc3ee4dbc8acdeb525c12c" type="function"/>
+ <keyword name="sigc::slot< T_return(T_arg...)>::operator=" link="classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html#a22759a1af0d37b9e7432bbb046ceff8a" type="function"/>
+ <keyword type="struct" name="sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil >" link="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html"/>
+ <keyword name="sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil >::parent_type" link="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a9937c7fbdb8be4e387fddcebf328fa41" type="typedef"/>
+ <keyword name="sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil >::slot" link="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#abdb48282bb8b1b5404fcea6474eca5a5" type="function"/>
+ <keyword name="sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil >::slot" link="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a9312dc3f121832083362b21334b939d2" type="function"/>
+ <keyword name="sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil >::slot" link="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ad35c264a95bfb4f29ed1fac4fda05a48" type="function"/>
+ <keyword name="sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil >::slot" link="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#aaf79a4f6ed84e20f9a800daa4f625d57" type="function"/>
+ <keyword name="sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil >::operator=" link="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a62c6b78bd545f7b6a2b0b85a6c3e6b00" type="function"/>
+ <keyword name="sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil >::operator=" link="classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#aba4c957436ba517b8b21a58e75ef9253" type="function"/>
+ <keyword type="struct" name="sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil >" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html"/>
+ <keyword name="sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::parent_type" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a2b6b5b8590577c765c7a32f7e619250a" type="typedef"/>
+ <keyword name="sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::slot" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ad34e10be904557368c241f53e972c8e7" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::slot" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a2765416a5563c2d264c892aa6ab5a83c" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::slot" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a5d486e3227ed5f73b791c4e202a168b4" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::slot" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ad22e5b50e474d072bb17489e9342c478" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::operator=" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a50efa6d5ba0613851a7aac56b98f7eb8" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::operator=" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a88a00e43c5ed084441655b2f9e32c621" type="function"/>
+ <keyword type="struct" name="sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::parent_type" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a867e776b644ca32a703866a424ae3ba5" type="typedef"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::slot" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#aae3ba9ffc1ab8ea95ba75dd6f5753c48" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::slot" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a7b7a49a2270daf31abdc237d440b21b1" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::slot" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a32b5350736a34c13c5e64d3ef6f5ba84" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::slot" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ad034a7e1a5344031ee9764c063054814" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::operator=" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#aa2298b81729a3f9879283a99ac31dfaf" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::operator=" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a98c52bf9ca78dc5f940ec5f5ca466bd9" type="function"/>
+ <keyword type="struct" name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::parent_type" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#adbafac5ab39a4a017406ac9587c9511c" type="typedef"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::slot" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#ad99678bf6a2affc9a1607046e158b22b" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::slot" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a508b21923e1ef3d7d689984132d89360" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::slot" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a492069e82b787edc381f4583bc1ab16d" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::slot" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a0e8a890566381060e52ffbd74cc4cca4" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::operator=" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a355a28cb253c5a14fb36574316f40e3b" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::operator=" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html#a190287bba2fd66fd0448c586660d1e41" type="function"/>
+ <keyword type="struct" name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::parent_type" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a704393344c1ba2f6bdda9b466bb81af1" type="typedef"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::slot" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#afb4ec5a164ca622ab9c1a97e61e9cfdc" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::slot" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#afb9ff761d6f8519ea01b4fd1c254ee60" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::slot" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#aa2691c7a5f59f54788db1b31d4870650" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::slot" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a4e1e1ecd839575d1d928325f8882fbfb" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::operator=" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#aebe6238dace66568d5135f1a7d41e8d1" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::operator=" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html#a0b0b9caae71710771aa3cd90f93755c5" type="function"/>
+ <keyword type="struct" name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::parent_type" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a013f4139332e23166f7db3be6da4ba91" type="typedef"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::slot" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a81c9e625279217aee1ae00696927c39e" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::slot" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#afab26283085a050db6d75a1bfe273f86" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::slot" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a8d5f076fe0207cabd9b2632382bedd89" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::slot" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#aad4ab45a94e4ec0bddf66c4d88e38b0a" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::operator=" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a3ca127357feda698616f9ed7209653ff" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::operator=" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html#a3195ba5b04503a37525bf2142c704f70" type="function"/>
+ <keyword type="struct" name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::parent_type" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a9c9028da9fc75a10c6c396673159d471" type="typedef"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::slot" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a290753f903665f059c25a4f71c9a9e16" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::slot" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a8be1480e392dcaa57d47e1c2a132edd4" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::slot" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#ab3081b23ab4fee6191cd8a2f57ba199d" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::slot" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a139944017d26e32ec7a347d94a1fc952" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::operator=" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#a5146567efe93808fbba32c114d2f302e" type="function"/>
+ <keyword name="sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::operator=" link="classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html#ace5ff8e4e75675985f148a3d2af0ce64" type="function"/>
+ <keyword type="struct" name="sigc::slot_base" link="classsigc_1_1slot__base.html"/>
+ <keyword name="sigc::slot_base::func_destroy_notify" link="classsigc_1_1slot__base.html#a7e1a0c2fe43a42187810e8997abeb341" type="typedef"/>
+ <keyword name="sigc::slot_base::slot_base" link="classsigc_1_1slot__base.html#a182d5db71ef371838c73bcf1c135cd9a" type="function"/>
+ <keyword name="sigc::slot_base::slot_base" link="classsigc_1_1slot__base.html#aadcbb54832b5207bddf89ac5433b531a" type="function"/>
+ <keyword name="sigc::slot_base::slot_base" link="classsigc_1_1slot__base.html#a5fbc2bf38a0d9ebcbe13d578d2b3d5a1" type="function"/>
+ <keyword name="sigc::slot_base::slot_base" link="classsigc_1_1slot__base.html#ad1fee67a5885e424c275ad0f48fc81b1" type="function"/>
+ <keyword name="sigc::slot_base::~slot_base" link="classsigc_1_1slot__base.html#a75c18c50860f63fb020fc2953576ea57" type="function"/>
+ <keyword name="sigc::slot_base::add_destroy_notify_callback" link="classsigc_1_1slot__base.html#a8e37cc8f4b57898a288680e59bea2694" type="function"/>
+ <keyword name="sigc::slot_base::block" link="classsigc_1_1slot__base.html#a657a8473164c963a5ca4828c88121bb9" type="function"/>
+ <keyword name="sigc::slot_base::blocked" link="classsigc_1_1slot__base.html#a2f266b6147c4a6bbc5b68994d2dc1517" type="function"/>
+ <keyword name="sigc::slot_base::disconnect" link="classsigc_1_1slot__base.html#a4042d221f7f07a7394d2eb0f14db2857" type="function"/>
+ <keyword name="sigc::slot_base::empty" link="classsigc_1_1slot__base.html#ae6ac6ca962a1f6a7506d0817165b5cef" type="function"/>
+ <keyword name="sigc::slot_base::operator bool" link="classsigc_1_1slot__base.html#a90d4d7d6037973a94d7dfd7ba9a5feb9" type="function"/>
+ <keyword name="sigc::slot_base::operator=" link="classsigc_1_1slot__base.html#a19522528264f1646f8ed982b0042ffad" type="function"/>
+ <keyword name="sigc::slot_base::operator=" link="classsigc_1_1slot__base.html#a64e36f28ee61a94c0496fe76f6b3e813" type="function"/>
+ <keyword name="sigc::slot_base::remove_destroy_notify_callback" link="classsigc_1_1slot__base.html#a69c55dedaa35626f288754d55b3da66c" type="function"/>
+ <keyword name="sigc::slot_base::set_parent" link="classsigc_1_1slot__base.html#aa7d281de451d5f47923f4ff1c5b7f2c9" type="function"/>
+ <keyword name="sigc::slot_base::unblock" link="classsigc_1_1slot__base.html#a25ad0bd4d2cea4dbfcd09f7d393d266d" type="function"/>
+ <keyword type="struct" name="sigc::slot_const_iterator" link="structsigc_1_1slot__const__iterator.html"/>
+ <keyword name="sigc::slot_const_iterator::difference_type" link="structsigc_1_1slot__const__iterator.html#ac111b0a48ab96f75e720f32171072bc5" type="typedef"/>
+ <keyword name="sigc::slot_const_iterator::iterator_category" link="structsigc_1_1slot__const__iterator.html#afc9dff16373a2fa7a4f373bd48a852c6" type="typedef"/>
+ <keyword name="sigc::slot_const_iterator::iterator_type" link="structsigc_1_1slot__const__iterator.html#a3466a35177b6a0999a12ff0ee10e91b9" type="typedef"/>
+ <keyword name="sigc::slot_const_iterator::pointer" link="structsigc_1_1slot__const__iterator.html#a28f3f0d2ac11dd8805d75682d8f38022" type="typedef"/>
+ <keyword name="sigc::slot_const_iterator::reference" link="structsigc_1_1slot__const__iterator.html#a8300967b4b29096e7ad0b96db04e095a" type="typedef"/>
+ <keyword name="sigc::slot_const_iterator::size_type" link="structsigc_1_1slot__const__iterator.html#adb1eeabfa619cbd9565aa0f9429ca5ed" type="typedef"/>
+ <keyword name="sigc::slot_const_iterator::slot_type" link="structsigc_1_1slot__const__iterator.html#ae377905cad9a91ca23d09877c72d82cd" type="typedef"/>
+ <keyword name="sigc::slot_const_iterator::value_type" link="structsigc_1_1slot__const__iterator.html#a20a9337066a01a137ea9945bdd509e80" type="typedef"/>
+ <keyword name="sigc::slot_const_iterator::slot_const_iterator" link="structsigc_1_1slot__const__iterator.html#a2b9e80b87a3400bb6f794c07f90d2d47" type="function"/>
+ <keyword name="sigc::slot_const_iterator::slot_const_iterator" link="structsigc_1_1slot__const__iterator.html#af84ef3ee54ae482534d88ac6a5b871ae" type="function"/>
+ <keyword name="sigc::slot_const_iterator::operator!=" link="structsigc_1_1slot__const__iterator.html#a0139736ee01df37af11f3551d76a2b53" type="function"/>
+ <keyword name="sigc::slot_const_iterator::operator*" link="structsigc_1_1slot__const__iterator.html#a37c9a5d5bba252e41a628bd1c87fd883" type="function"/>
+ <keyword name="sigc::slot_const_iterator::operator++" link="structsigc_1_1slot__const__iterator.html#aed166d716b032a781d2169c919cefdc9" type="function"/>
+ <keyword name="sigc::slot_const_iterator::operator++" link="structsigc_1_1slot__const__iterator.html#aa2f7b6d4c7aa7192fca0bdcc08b74ba6" type="function"/>
+ <keyword name="sigc::slot_const_iterator::operator--" link="structsigc_1_1slot__const__iterator.html#a1c1d7d7798914c80d6a60d87c4b24c0a" type="function"/>
+ <keyword name="sigc::slot_const_iterator::operator--" link="structsigc_1_1slot__const__iterator.html#a9ece84f63e078754915dcc6dc6ee1cc4" type="function"/>
+ <keyword name="sigc::slot_const_iterator::operator->" link="structsigc_1_1slot__const__iterator.html#afd0ff56e0779787da2c7dfdb0ef4630c" type="function"/>
+ <keyword name="sigc::slot_const_iterator::operator==" link="structsigc_1_1slot__const__iterator.html#af88c3fcadb7ce415fcad4bd5dafad087" type="function"/>
+ <keyword type="struct" name="sigc::slot_iterator" link="structsigc_1_1slot__iterator.html"/>
+ <keyword name="sigc::slot_iterator::difference_type" link="structsigc_1_1slot__iterator.html#adb6307ee06c592d67ecef0607f319d5e" type="typedef"/>
+ <keyword name="sigc::slot_iterator::iterator_category" link="structsigc_1_1slot__iterator.html#a0c882521b418b9faaac879a1d337ace5" type="typedef"/>
+ <keyword name="sigc::slot_iterator::iterator_type" link="structsigc_1_1slot__iterator.html#a189fa620b9d90dc1a224d9ad91da5011" type="typedef"/>
+ <keyword name="sigc::slot_iterator::pointer" link="structsigc_1_1slot__iterator.html#afb36f2add6064e0d7e7ae63ee2ddcde9" type="typedef"/>
+ <keyword name="sigc::slot_iterator::reference" link="structsigc_1_1slot__iterator.html#aa3e69a557b73d817a1951af1b1767632" type="typedef"/>
+ <keyword name="sigc::slot_iterator::size_type" link="structsigc_1_1slot__iterator.html#a1dd8ea0a80b5bb0f936833a1c2e363ed" type="typedef"/>
+ <keyword name="sigc::slot_iterator::slot_type" link="structsigc_1_1slot__iterator.html#af7a0ed93fca0064021d77275305e04a9" type="typedef"/>
+ <keyword name="sigc::slot_iterator::value_type" link="structsigc_1_1slot__iterator.html#a94f7fcbd3224e1f7e88b84f9e326b0b3" type="typedef"/>
+ <keyword name="sigc::slot_iterator::slot_iterator" link="structsigc_1_1slot__iterator.html#a82d4023ad9dc38dcde4cae6bf65cd8c8" type="function"/>
+ <keyword name="sigc::slot_iterator::slot_iterator" link="structsigc_1_1slot__iterator.html#a07933d72e788285673121e5ce019a260" type="function"/>
+ <keyword name="sigc::slot_iterator::operator!=" link="structsigc_1_1slot__iterator.html#a880c8929759eca2fc7fb55cb0c813c55" type="function"/>
+ <keyword name="sigc::slot_iterator::operator*" link="structsigc_1_1slot__iterator.html#aa01dddd6f7b4e1a726a55cd1d430f398" type="function"/>
+ <keyword name="sigc::slot_iterator::operator++" link="structsigc_1_1slot__iterator.html#af5a3b852c1c6e8f69c41f64a17204758" type="function"/>
+ <keyword name="sigc::slot_iterator::operator++" link="structsigc_1_1slot__iterator.html#a7469f1ad5f1802d7a04f031ee4b3e54e" type="function"/>
+ <keyword name="sigc::slot_iterator::operator--" link="structsigc_1_1slot__iterator.html#a8aeef4e41dc0930beaa8d6a37b27775c" type="function"/>
+ <keyword name="sigc::slot_iterator::operator--" link="structsigc_1_1slot__iterator.html#afd2ebfa71c2df96290f2bce0746d6fa5" type="function"/>
+ <keyword name="sigc::slot_iterator::operator->" link="structsigc_1_1slot__iterator.html#a0a77bd2eccf05cecbdf3b690c5301540" type="function"/>
+ <keyword name="sigc::slot_iterator::operator==" link="structsigc_1_1slot__iterator.html#af2b4e16f15258f6cd98f8049afd0b88d" type="function"/>
+ <keyword type="struct" name="sigc::slot_list" link="structsigc_1_1slot__list.html"/>
+ <keyword name="sigc::slot_list::const_iterator" link="structsigc_1_1slot__list.html#a957838a7111e132824c10c2d5a897a0b" type="typedef"/>
+ <keyword name="sigc::slot_list::const_reference" link="structsigc_1_1slot__list.html#a3ac6e61271e7e8623d1bd493c61f1214" type="typedef"/>
+ <keyword name="sigc::slot_list::const_reverse_iterator" link="structsigc_1_1slot__list.html#a8293bfca54539958326f57375e4d8c14" type="typedef"/>
+ <keyword name="sigc::slot_list::iterator" link="structsigc_1_1slot__list.html#a9774e07e467d9463e6e7cc7aa2f5c05f" type="typedef"/>
+ <keyword name="sigc::slot_list::reference" link="structsigc_1_1slot__list.html#ab0f2255639f24ff02d45f97994bc0e11" type="typedef"/>
+ <keyword name="sigc::slot_list::reverse_iterator" link="structsigc_1_1slot__list.html#addb44a7590825f917b3fcf0179fadadb" type="typedef"/>
+ <keyword name="sigc::slot_list::slot_type" link="structsigc_1_1slot__list.html#af769819a62b19adb888eb231709e894f" type="typedef"/>
+ <keyword name="sigc::slot_list::slot_list" link="structsigc_1_1slot__list.html#aa83ff2d263581f80f9d15d14fa31bc7a" type="function"/>
+ <keyword name="sigc::slot_list::slot_list" link="structsigc_1_1slot__list.html#a5baac8e52fda5f6fc4fa31bed67077e3" type="function"/>
+ <keyword name="sigc::slot_list::back" link="structsigc_1_1slot__list.html#a2b1145f2e387c041913d01b5b197f12b" type="function"/>
+ <keyword name="sigc::slot_list::back" link="structsigc_1_1slot__list.html#a09c5090912b6a7920269d3959e9698f4" type="function"/>
+ <keyword name="sigc::slot_list::begin" link="structsigc_1_1slot__list.html#ae179ec4300ddc793492bc574f6a92fec" type="function"/>
+ <keyword name="sigc::slot_list::begin" link="structsigc_1_1slot__list.html#af5d0b9141e3206f2a7512e1ac4cc65fc" type="function"/>
+ <keyword name="sigc::slot_list::end" link="structsigc_1_1slot__list.html#affef6e4e62e4be8743c56aa8753f76d1" type="function"/>
+ <keyword name="sigc::slot_list::end" link="structsigc_1_1slot__list.html#a1d5274891fad64cd2449914728b60bc1" type="function"/>
+ <keyword name="sigc::slot_list::erase" link="structsigc_1_1slot__list.html#a76e40607d0329865e549ac78105a5d7d" type="function"/>
+ <keyword name="sigc::slot_list::erase" link="structsigc_1_1slot__list.html#a092ed557b1519062804a41e9b527e99d" type="function"/>
+ <keyword name="sigc::slot_list::front" link="structsigc_1_1slot__list.html#abcd398b9cb6fe9506e548d121081163a" type="function"/>
+ <keyword name="sigc::slot_list::front" link="structsigc_1_1slot__list.html#ac44ca78cb266a8c46758b276cea151a1" type="function"/>
+ <keyword name="sigc::slot_list::insert" link="structsigc_1_1slot__list.html#a34c421956609463692527793e49b87ae" type="function"/>
+ <keyword name="sigc::slot_list::insert" link="structsigc_1_1slot__list.html#ac4e8d8b623aed063b7873b5d2e1ce5f5" type="function"/>
+ <keyword name="sigc::slot_list::pop_back" link="structsigc_1_1slot__list.html#abb28f82ef0cbc78a86a4becd61b0c9ff" type="function"/>
+ <keyword name="sigc::slot_list::pop_front" link="structsigc_1_1slot__list.html#a9244005ecc265b07b7f451e63662686e" type="function"/>
+ <keyword name="sigc::slot_list::push_back" link="structsigc_1_1slot__list.html#a5c7401657a6020c14616e62b20949de8" type="function"/>
+ <keyword name="sigc::slot_list::push_back" link="structsigc_1_1slot__list.html#a48bf437419930c92756ee3b2162d08ad" type="function"/>
+ <keyword name="sigc::slot_list::push_front" link="structsigc_1_1slot__list.html#a5bb241c13cb363825f787ecd244ebf7d" type="function"/>
+ <keyword name="sigc::slot_list::push_front" link="structsigc_1_1slot__list.html#a4179f2c80be5fb65544b19b3b1d4807e" type="function"/>
+ <keyword name="sigc::slot_list::rbegin" link="structsigc_1_1slot__list.html#a898411734692d01a320b20a20d9e6978" type="function"/>
+ <keyword name="sigc::slot_list::rbegin" link="structsigc_1_1slot__list.html#a1d4d33c9ac07a6012332d89100e8fbeb" type="function"/>
+ <keyword name="sigc::slot_list::rend" link="structsigc_1_1slot__list.html#ae4759ca19577b31dca5116292e7de19c" type="function"/>
+ <keyword name="sigc::slot_list::rend" link="structsigc_1_1slot__list.html#a805f74b49477673660b039576cbec20f" type="function"/>
+ <keyword type="struct" name="sigc::track_obj_functor1" link="classsigc_1_1track__obj__functor1.html"/>
+ <keyword name="sigc::track_obj_functor1::adaptor_type" link="classsigc_1_1track__obj__functor1.html#ab36332c8e8815546730b525f739d9ebf" type="typedef"/>
+ <keyword name="sigc::track_obj_functor1::result_type" link="classsigc_1_1track__obj__functor1.html#a17ad87a124cb6fafc37a2d573d47f222" type="typedef"/>
+ <keyword name="sigc::track_obj_functor1::track_obj_functor1" link="classsigc_1_1track__obj__functor1.html#a1bcc00d3b665af8f40fa18936fab5304" type="function"/>
+ <keyword name="sigc::track_obj_functor1::operator()" link="classsigc_1_1track__obj__functor1.html#a3a4b2ca8d1c83356dcf7d5ba93051986" type="function"/>
+ <keyword name="sigc::track_obj_functor1::operator()" link="classsigc_1_1track__obj__functor1.html#a3da19bfd10f0b9f84ae83b06f8211ae6" type="function"/>
+ <keyword name="sigc::track_obj_functor1::operator()" link="classsigc_1_1track__obj__functor1.html#a933452a80a7c98d4865624d2f60b2527" type="function"/>
+ <keyword name="sigc::track_obj_functor1::operator()" link="classsigc_1_1track__obj__functor1.html#abb1206272535caa14e1109d198ab0b1f" type="function"/>
+ <keyword name="sigc::track_obj_functor1::operator()" link="classsigc_1_1track__obj__functor1.html#a94fba99da25a041007a4f2f07b19c784" type="function"/>
+ <keyword name="sigc::track_obj_functor1::operator()" link="classsigc_1_1track__obj__functor1.html#a8bf05204e43be21b027a79ffb7aed13e" type="function"/>
+ <keyword name="sigc::track_obj_functor1::operator()" link="classsigc_1_1track__obj__functor1.html#a610d215dd82c2a3112aef9bb29edd856" type="function"/>
+ <keyword name="sigc::track_obj_functor1::operator()" link="classsigc_1_1track__obj__functor1.html#a758ed994bc823ce29001873838384ac0" type="function"/>
+ <keyword type="struct" name="sigc::track_obj_functor2" link="classsigc_1_1track__obj__functor2.html"/>
+ <keyword name="sigc::track_obj_functor2::track_obj_functor2" link="classsigc_1_1track__obj__functor2.html#ae12b4c85e92a265c011fccf090fa6947" type="function"/>
+ <keyword type="struct" name="sigc::track_obj_functor3" link="classsigc_1_1track__obj__functor3.html"/>
+ <keyword name="sigc::track_obj_functor3::track_obj_functor3" link="classsigc_1_1track__obj__functor3.html#add83622dc2ad7cd561d2c59768eea45a" type="function"/>
+ <keyword type="struct" name="sigc::track_obj_functor4" link="classsigc_1_1track__obj__functor4.html"/>
+ <keyword name="sigc::track_obj_functor4::track_obj_functor4" link="classsigc_1_1track__obj__functor4.html#a29f48beae82cf67da9b70a51da35a2e9" type="function"/>
+ <keyword type="struct" name="sigc::track_obj_functor5" link="classsigc_1_1track__obj__functor5.html"/>
+ <keyword name="sigc::track_obj_functor5::track_obj_functor5" link="classsigc_1_1track__obj__functor5.html#a1f0481289e8c48acc4cc6561c8f0c8b6" type="function"/>
+ <keyword type="struct" name="sigc::track_obj_functor6" link="classsigc_1_1track__obj__functor6.html"/>
+ <keyword name="sigc::track_obj_functor6::track_obj_functor6" link="classsigc_1_1track__obj__functor6.html#a70b36db3f8cafb77c48269c3e4c68714" type="function"/>
+ <keyword type="struct" name="sigc::track_obj_functor7" link="classsigc_1_1track__obj__functor7.html"/>
+ <keyword name="sigc::track_obj_functor7::track_obj_functor7" link="classsigc_1_1track__obj__functor7.html#a77667be610a480c7afdb928533b02651" type="function"/>
+ <keyword type="struct" name="sigc::trackable" link="structsigc_1_1trackable.html"/>
+ <keyword name="sigc::trackable::func_destroy_notify" link="structsigc_1_1trackable.html#a3338954d7565534bd945290b798e13ed" type="typedef"/>
+ <keyword name="sigc::trackable::trackable" link="structsigc_1_1trackable.html#a7e1348841e762fb41b41c6f2ce9fa073" type="function"/>
+ <keyword name="sigc::trackable::trackable" link="structsigc_1_1trackable.html#ac8431d9452c9698a012597e6560c72fa" type="function"/>
+ <keyword name="sigc::trackable::trackable" link="structsigc_1_1trackable.html#aba42ed8afb6598106cf68c18a7387f18" type="function"/>
+ <keyword name="sigc::trackable::~trackable" link="structsigc_1_1trackable.html#a75587da09e30031db7a2519843f1f4fb" type="function"/>
+ <keyword name="sigc::trackable::add_destroy_notify_callback" link="structsigc_1_1trackable.html#aed95b40846f61b4f202348c71d5913ea" type="function"/>
+ <keyword name="sigc::trackable::notify_callbacks" link="structsigc_1_1trackable.html#af2e23cfe7adc1ca844a3350bbac557cb" type="function"/>
+ <keyword name="sigc::trackable::operator=" link="structsigc_1_1trackable.html#a7494fbad23a65932ff1457d00d4edaf5" type="function"/>
+ <keyword name="sigc::trackable::operator=" link="structsigc_1_1trackable.html#ac3d61cdb452dc46fcdc8a8d42d9c079d" type="function"/>
+ <keyword name="sigc::trackable::remove_destroy_notify_callback" link="structsigc_1_1trackable.html#ad1c1845ff5b356f13b32180077f83cff" type="function"/>
+ <keyword type="struct" name="sigc::type_trait" link="structsigc_1_1type__trait.html"/>
+ <keyword name="sigc::type_trait::pass" link="structsigc_1_1type__trait.html#aebfa426334f8de7b93031de35d2495e3" type="typedef"/>
+ <keyword name="sigc::type_trait::take" link="structsigc_1_1type__trait.html#a191a797ea6e2d851287b8a87b6305157" type="typedef"/>
+ <keyword type="struct" name="sigc::type_trait< const T_type & >" link="structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html"/>
+ <keyword name="sigc::type_trait< const T_type & >::pass" link="structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html#a7b9cd2a3e6e7cf986e4e25e05c665c73" type="typedef"/>
+ <keyword name="sigc::type_trait< const T_type & >::take" link="structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html#a2c3a2a62adee114867045a7f77096435" type="typedef"/>
+ <keyword type="struct" name="sigc::type_trait< T_type & >" link="structsigc_1_1type__trait_3_01T__type_01_6_01_4.html"/>
+ <keyword name="sigc::type_trait< T_type & >::pass" link="structsigc_1_1type__trait_3_01T__type_01_6_01_4.html#a1b24e79fed94df3fc0e7574e0ae1c991" type="typedef"/>
+ <keyword name="sigc::type_trait< T_type & >::take" link="structsigc_1_1type__trait_3_01T__type_01_6_01_4.html#a604c7ad05de42e3f9d28ab45c8d865b5" type="typedef"/>
+ <keyword type="struct" name="sigc::type_trait< T_type[N]>" link="structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html"/>
+ <keyword name="sigc::type_trait< T_type[N]>::pass" link="structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html#abfd06dd56be6fda2436e9e15acb1fc72" type="typedef"/>
+ <keyword name="sigc::type_trait< T_type[N]>::take" link="structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html#a9cb9e2faaa68a89ef1a74b8b7c98d81e" type="typedef"/>
+ <keyword type="struct" name="sigc::type_trait< void >" link="structsigc_1_1type__trait_3_01void_01_4.html"/>
+ <keyword name="sigc::type_trait< void >::pass" link="structsigc_1_1type__trait_3_01void_01_4.html#ab5d97b4ec126f3afeaf67e9a6b05b0be" type="typedef"/>
+ <keyword name="sigc::type_trait< void >::take" link="structsigc_1_1type__trait_3_01void_01_4.html#a40d187392469ee48d24838ef38531b90" type="typedef"/>
+ <keyword type="struct" name="sigc::unwrap_reference" link="structsigc_1_1unwrap__reference.html"/>
+ <keyword name="sigc::unwrap_reference::type" link="structsigc_1_1unwrap__reference.html#af35cad963fc073623282a2fb9c81f02a" type="typedef"/>
+ <keyword type="struct" name="sigc::unwrap_reference< const_reference_wrapper< T_type > >" link="structsigc_1_1unwrap__reference_3_01const__reference__wrapper_3_01T__type_01_4_01_4.html"/>
+ <keyword name="sigc::unwrap_reference< const_reference_wrapper< T_type > >::type" link="structsigc_1_1unwrap__reference_3_01const__reference__wrapper_3_01T__type_01_4_01_4.html#a9820651050b0059841f9a92d9c478ba8" type="typedef"/>
+ <keyword type="struct" name="sigc::unwrap_reference< reference_wrapper< T_type > >" link="structsigc_1_1unwrap__reference_3_01reference__wrapper_3_01T__type_01_4_01_4.html"/>
+ <keyword name="sigc::unwrap_reference< reference_wrapper< T_type > >::type" link="structsigc_1_1unwrap__reference_3_01reference__wrapper_3_01T__type_01_4_01_4.html#a25182a927492ff79290f9820f7131e58" type="typedef"/>
+ <keyword type="struct" name="sigc::unwrap_reference< std::reference_wrapper< T_type > >" link="structsigc_1_1unwrap__reference_3_01std_1_1reference__wrapper_3_01T__type_01_4_01_4.html"/>
+ <keyword name="sigc::unwrap_reference< std::reference_wrapper< T_type > >::type" link="structsigc_1_1unwrap__reference_3_01std_1_1reference__wrapper_3_01T__type_01_4_01_4.html#a2a9edeecf0de1843fb4d218f68ae86c4" type="typedef"/>
+ <keyword type="struct" name="sigc::visitor" link="structsigc_1_1visitor.html"/>
+ <keyword name="sigc::visitor::do_visit_each" link="structsigc_1_1visitor.html#a9fe5d6be845e622a99a0db5d3621d4b3" type="function"/>
+ <keyword type="struct" name="sigc::volatile_limit_reference" link="classsigc_1_1volatile__limit__reference.html"/>
+ <keyword name="sigc::volatile_limit_reference::volatile_limit_reference" link="classsigc_1_1volatile__limit__reference.html#acb3e6e1ecc628343f94faae718b58066" type="function"/>
+ <keyword name="sigc::volatile_limit_reference::invoke" link="classsigc_1_1volatile__limit__reference.html#a0157cc89d9db4032c7a8f9159ebaeff3" type="function"/>
+ <keyword name="sigc::volatile_limit_reference::visit" link="classsigc_1_1volatile__limit__reference.html#a4d67fe2d9d27c326136a9e5ac13a1a75" type="function"/>
+ <keyword type="struct" name="sigc::volatile_limit_reference< T_type, true >" link="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html"/>
+ <keyword name="sigc::volatile_limit_reference< T_type, true >::volatile_limit_reference" link="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html#aa0b69d0a82616d6db2eb86d7a041df23" type="function"/>
+ <keyword name="sigc::volatile_limit_reference< T_type, true >::invoke" link="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html#aebad0975106ae62368e4f5c0ee0a6170" type="function"/>
+ <keyword name="sigc::volatile_limit_reference< T_type, true >::visit" link="classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html#a187454d57b2c1edefb5594fcd0175835" type="function"/>
+ <keyword type="struct" name="sigc::volatile_mem_functor0" link="classsigc_1_1volatile__mem__functor0.html"/>
+ <keyword name="sigc::volatile_mem_functor0::function_type" link="classsigc_1_1volatile__mem__functor0.html#a2f0448d35b580f2b4884292f29b19b2f" type="typedef"/>
+ <keyword name="sigc::volatile_mem_functor0::result_type" link="classsigc_1_1volatile__mem__functor0.html#a41fbd67d6bbde0818b880f08f6295396" type="typedef"/>
+ <keyword name="sigc::volatile_mem_functor0::volatile_mem_functor0" link="classsigc_1_1volatile__mem__functor0.html#ae29bbe3e668b370d2788631465daa63c" type="function"/>
+ <keyword name="sigc::volatile_mem_functor0::volatile_mem_functor0" link="classsigc_1_1volatile__mem__functor0.html#aa4e5e279480d50940eb4b73b9c61b938" type="function"/>
+ <keyword name="sigc::volatile_mem_functor0::operator()" link="classsigc_1_1volatile__mem__functor0.html#aa5df40ec8fb385594c673a07f3ff8044" type="function"/>
+ <keyword name="sigc::volatile_mem_functor0::operator()" link="classsigc_1_1volatile__mem__functor0.html#af627ef410fac7ec5d2ee842d8f89fe51" type="function"/>
+ <keyword type="struct" name="sigc::volatile_mem_functor1" link="classsigc_1_1volatile__mem__functor1.html"/>
+ <keyword name="sigc::volatile_mem_functor1::function_type" link="classsigc_1_1volatile__mem__functor1.html#a49228c222297c3f116b132370c3f054d" type="typedef"/>
+ <keyword name="sigc::volatile_mem_functor1::result_type" link="classsigc_1_1volatile__mem__functor1.html#a3bcbf6ae6e950d35e4ac7b33fa066877" type="typedef"/>
+ <keyword name="sigc::volatile_mem_functor1::volatile_mem_functor1" link="classsigc_1_1volatile__mem__functor1.html#a30ec3be683a2c466b23da53c8025608b" type="function"/>
+ <keyword name="sigc::volatile_mem_functor1::volatile_mem_functor1" link="classsigc_1_1volatile__mem__functor1.html#a86d592aee0ca1d853b64b52224054029" type="function"/>
+ <keyword name="sigc::volatile_mem_functor1::operator()" link="classsigc_1_1volatile__mem__functor1.html#a98cdb61b4c623e44d5b60650098bddfd" type="function"/>
+ <keyword name="sigc::volatile_mem_functor1::operator()" link="classsigc_1_1volatile__mem__functor1.html#a69185452103c51af81b78e95504eb95c" type="function"/>
+ <keyword type="struct" name="sigc::volatile_mem_functor2" link="classsigc_1_1volatile__mem__functor2.html"/>
+ <keyword name="sigc::volatile_mem_functor2::function_type" link="classsigc_1_1volatile__mem__functor2.html#a5faa6d84f05d64ff92e9e4ba6b8bcc1f" type="typedef"/>
+ <keyword name="sigc::volatile_mem_functor2::result_type" link="classsigc_1_1volatile__mem__functor2.html#a67719071ed0eacd994fa6fe300cfb24d" type="typedef"/>
+ <keyword name="sigc::volatile_mem_functor2::volatile_mem_functor2" link="classsigc_1_1volatile__mem__functor2.html#a273bbe27bc7b190d8457408cd328c1f9" type="function"/>
+ <keyword name="sigc::volatile_mem_functor2::volatile_mem_functor2" link="classsigc_1_1volatile__mem__functor2.html#acba5e052ebb8884ff02cab194a2f794e" type="function"/>
+ <keyword name="sigc::volatile_mem_functor2::operator()" link="classsigc_1_1volatile__mem__functor2.html#a814c8abe52fa858da9f8dfbda8efafc9" type="function"/>
+ <keyword name="sigc::volatile_mem_functor2::operator()" link="classsigc_1_1volatile__mem__functor2.html#ac4c64a4812347e17744e33e5e37775d7" type="function"/>
+ <keyword type="struct" name="sigc::volatile_mem_functor3" link="classsigc_1_1volatile__mem__functor3.html"/>
+ <keyword name="sigc::volatile_mem_functor3::function_type" link="classsigc_1_1volatile__mem__functor3.html#aadf62624c12ef82ade8114184f0882c9" type="typedef"/>
+ <keyword name="sigc::volatile_mem_functor3::result_type" link="classsigc_1_1volatile__mem__functor3.html#a229fe43026e97bbcf80215ea8e9fa828" type="typedef"/>
+ <keyword name="sigc::volatile_mem_functor3::volatile_mem_functor3" link="classsigc_1_1volatile__mem__functor3.html#ad2319eebf06194ff516c27f581cbd7a5" type="function"/>
+ <keyword name="sigc::volatile_mem_functor3::volatile_mem_functor3" link="classsigc_1_1volatile__mem__functor3.html#a2364e6ab68a8128ba9e9973c66c0ce1d" type="function"/>
+ <keyword name="sigc::volatile_mem_functor3::operator()" link="classsigc_1_1volatile__mem__functor3.html#ab525bf6e0a4057a4f3f8f98ff6c1bd74" type="function"/>
+ <keyword name="sigc::volatile_mem_functor3::operator()" link="classsigc_1_1volatile__mem__functor3.html#a39944451f3bb1538828e45b66f082ea0" type="function"/>
+ <keyword type="struct" name="sigc::volatile_mem_functor4" link="classsigc_1_1volatile__mem__functor4.html"/>
+ <keyword name="sigc::volatile_mem_functor4::function_type" link="classsigc_1_1volatile__mem__functor4.html#a697cad0c578cd4ba3e04f6db8a39e283" type="typedef"/>
+ <keyword name="sigc::volatile_mem_functor4::result_type" link="classsigc_1_1volatile__mem__functor4.html#a58dd95fa47c02a9ba6340682c7dbbcb0" type="typedef"/>
+ <keyword name="sigc::volatile_mem_functor4::volatile_mem_functor4" link="classsigc_1_1volatile__mem__functor4.html#a5ba462855081b617085e59e7566927a7" type="function"/>
+ <keyword name="sigc::volatile_mem_functor4::volatile_mem_functor4" link="classsigc_1_1volatile__mem__functor4.html#ab86348ff91ed7ce4cadff97c157e4024" type="function"/>
+ <keyword name="sigc::volatile_mem_functor4::operator()" link="classsigc_1_1volatile__mem__functor4.html#a58491d7fd980863c7abd311624ada052" type="function"/>
+ <keyword name="sigc::volatile_mem_functor4::operator()" link="classsigc_1_1volatile__mem__functor4.html#a86a0e482790971e3674b9ba488e10127" type="function"/>
+ <keyword type="struct" name="sigc::volatile_mem_functor5" link="classsigc_1_1volatile__mem__functor5.html"/>
+ <keyword name="sigc::volatile_mem_functor5::function_type" link="classsigc_1_1volatile__mem__functor5.html#a43ce719034586bbd097c823376c288ef" type="typedef"/>
+ <keyword name="sigc::volatile_mem_functor5::result_type" link="classsigc_1_1volatile__mem__functor5.html#ab647ea2e44db475cc2d4bae8be842127" type="typedef"/>
+ <keyword name="sigc::volatile_mem_functor5::volatile_mem_functor5" link="classsigc_1_1volatile__mem__functor5.html#abe1011a71cd8e78d248e072fb7d60231" type="function"/>
+ <keyword name="sigc::volatile_mem_functor5::volatile_mem_functor5" link="classsigc_1_1volatile__mem__functor5.html#a98e43ac4bafb96958bbbf658154794d0" type="function"/>
+ <keyword name="sigc::volatile_mem_functor5::operator()" link="classsigc_1_1volatile__mem__functor5.html#a4a4b9b8ce1ce396ed9fa355ed56cf7b2" type="function"/>
+ <keyword name="sigc::volatile_mem_functor5::operator()" link="classsigc_1_1volatile__mem__functor5.html#ab6449c487e42fc9810c0f8d5a6cc243f" type="function"/>
+ <keyword type="struct" name="sigc::volatile_mem_functor6" link="classsigc_1_1volatile__mem__functor6.html"/>
+ <keyword name="sigc::volatile_mem_functor6::function_type" link="classsigc_1_1volatile__mem__functor6.html#a67b3a13a2f595360ff6f78cb96efe9d1" type="typedef"/>
+ <keyword name="sigc::volatile_mem_functor6::result_type" link="classsigc_1_1volatile__mem__functor6.html#a1ce192c145ec5af4c826ccb2619cf002" type="typedef"/>
+ <keyword name="sigc::volatile_mem_functor6::volatile_mem_functor6" link="classsigc_1_1volatile__mem__functor6.html#a782bbd4bff8bd939a008ceb9e0511bae" type="function"/>
+ <keyword name="sigc::volatile_mem_functor6::volatile_mem_functor6" link="classsigc_1_1volatile__mem__functor6.html#a55c428dacaaff7f5dcd48ec02b53ed60" type="function"/>
+ <keyword name="sigc::volatile_mem_functor6::operator()" link="classsigc_1_1volatile__mem__functor6.html#a2fdda8079c742fd0366c3fc057ea45e5" type="function"/>
+ <keyword name="sigc::volatile_mem_functor6::operator()" link="classsigc_1_1volatile__mem__functor6.html#a00320a319413753f756304a8db0fbf51" type="function"/>
+ <keyword type="struct" name="sigc::volatile_mem_functor7" link="classsigc_1_1volatile__mem__functor7.html"/>
+ <keyword name="sigc::volatile_mem_functor7::function_type" link="classsigc_1_1volatile__mem__functor7.html#a4ee701fd029c3b7f2f3a3af1aef428a0" type="typedef"/>
+ <keyword name="sigc::volatile_mem_functor7::result_type" link="classsigc_1_1volatile__mem__functor7.html#a4762374376dcb7b11c77372edab78823" type="typedef"/>
+ <keyword name="sigc::volatile_mem_functor7::volatile_mem_functor7" link="classsigc_1_1volatile__mem__functor7.html#a07834a50703bf92aad9bc167fa256d24" type="function"/>
+ <keyword name="sigc::volatile_mem_functor7::volatile_mem_functor7" link="classsigc_1_1volatile__mem__functor7.html#a809146646d2dd726a385344f455402e4" type="function"/>
+ <keyword name="sigc::volatile_mem_functor7::operator()" link="classsigc_1_1volatile__mem__functor7.html#a05ed4811582f583a1a1e11b1a8951a21" type="function"/>
+ <keyword name="sigc::volatile_mem_functor7::operator()" link="classsigc_1_1volatile__mem__functor7.html#ae587c12caf1c68886fbf001b2c8acc03" type="function"/>
+ <keyword type="struct" name="signal0< T_return, nil >" link="classsigc_1_1signal0.html"/>
+ <keyword name="signal0< T_return, nil >::const_iterator" link="classsigc_1_1signal0.html#ad4f7c62954f5c270e115d9b2a2df15ea" type="typedef"/>
+ <keyword name="signal0< T_return, nil >::const_reverse_iterator" link="classsigc_1_1signal0.html#a476f559a69eef5999c99cd6262a9aa2f" type="typedef"/>
+ <keyword name="signal0< T_return, nil >::emitter_type" link="classsigc_1_1signal0.html#ac7eafdced2d325d6003327b4360bc2dd" type="typedef"/>
+ <keyword name="signal0< T_return, nil >::iterator" link="classsigc_1_1signal0.html#ad61e875748cf4e1c2a6d89a930ae093e" type="typedef"/>
+ <keyword name="signal0< T_return, nil >::result_type" link="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de" type="typedef"/>
+ <keyword name="signal0< T_return, nil >::reverse_iterator" link="classsigc_1_1signal0.html#a1d9c390974304392ed12ee81543ab997" type="typedef"/>
+ <keyword name="signal0< T_return, nil >::slot_list_type" link="classsigc_1_1signal0.html#add195c1c738ee8efe10294f21d258b77" type="typedef"/>
+ <keyword name="signal0< T_return, nil >::slot_type" link="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287" type="typedef"/>
+ <keyword name="signal0< T_return, nil >::signal0" link="classsigc_1_1signal0.html#a2fb24e11a8f645e5122646ea2b4a5d2f" type="function"/>
+ <keyword name="signal0< T_return, nil >::signal0" link="classsigc_1_1signal0.html#a7dc687f1afb4088a3d888aa05dbf56d9" type="function"/>
+ <keyword name="signal0< T_return, nil >::signal0" link="classsigc_1_1signal0.html#ac1b915a86d0b75fd4e90c2a92f7ebc49" type="function"/>
+ <keyword name="signal0< T_return, nil >::connect" link="classsigc_1_1signal0.html#a609b1e0770f47c9081a3de56b65314d2" type="function"/>
+ <keyword name="signal0< T_return, nil >::connect" link="classsigc_1_1signal0.html#a9b78954271b6dba5e926bd960f3e7905" type="function"/>
+ <keyword name="signal0< T_return, nil >::emit" link="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8" type="function"/>
+ <keyword name="signal0< T_return, nil >::emit_reverse" link="classsigc_1_1signal0.html#abdae39f9a7abd6133c03d65224c227d6" type="function"/>
+ <keyword name="signal0< T_return, nil >::make_slot" link="classsigc_1_1signal0.html#a3295536428e5e0d6478ac10e2daff736" type="function"/>
+ <keyword name="signal0< T_return, nil >::operator()" link="classsigc_1_1signal0.html#a2dd3042c0681542ed6f2de5840f713a1" type="function"/>
+ <keyword name="signal0< T_return, nil >::operator=" link="classsigc_1_1signal0.html#a4e8311eac2fd7f8ecd10bff8225ed9e3" type="function"/>
+ <keyword name="signal0< T_return, nil >::operator=" link="classsigc_1_1signal0.html#a693aa3743236012416349bfac56d31b6" type="function"/>
+ <keyword name="signal0< T_return, nil >::slots" link="classsigc_1_1signal0.html#a5576113ddfd6b92a96f86072262307f9" type="function"/>
+ <keyword name="signal0< T_return, nil >::slots" link="classsigc_1_1signal0.html#a73523d71edd7fb4294324e9561db6f3c" type="function"/>
+ <keyword type="struct" name="signal0< T_return, T_accumulator >" link="classsigc_1_1signal0.html"/>
+ <keyword name="signal0< T_return, T_accumulator >::const_iterator" link="classsigc_1_1signal0.html#ad4f7c62954f5c270e115d9b2a2df15ea" type="typedef"/>
+ <keyword name="signal0< T_return, T_accumulator >::const_reverse_iterator" link="classsigc_1_1signal0.html#a476f559a69eef5999c99cd6262a9aa2f" type="typedef"/>
+ <keyword name="signal0< T_return, T_accumulator >::emitter_type" link="classsigc_1_1signal0.html#ac7eafdced2d325d6003327b4360bc2dd" type="typedef"/>
+ <keyword name="signal0< T_return, T_accumulator >::iterator" link="classsigc_1_1signal0.html#ad61e875748cf4e1c2a6d89a930ae093e" type="typedef"/>
+ <keyword name="signal0< T_return, T_accumulator >::result_type" link="classsigc_1_1signal0.html#ae291a90c83f8ad1cdcc7c2a4cdd958de" type="typedef"/>
+ <keyword name="signal0< T_return, T_accumulator >::reverse_iterator" link="classsigc_1_1signal0.html#a1d9c390974304392ed12ee81543ab997" type="typedef"/>
+ <keyword name="signal0< T_return, T_accumulator >::slot_list_type" link="classsigc_1_1signal0.html#add195c1c738ee8efe10294f21d258b77" type="typedef"/>
+ <keyword name="signal0< T_return, T_accumulator >::slot_type" link="classsigc_1_1signal0.html#ae3fc90cec344b6585979e77d2b359287" type="typedef"/>
+ <keyword name="signal0< T_return, T_accumulator >::signal0" link="classsigc_1_1signal0.html#a2fb24e11a8f645e5122646ea2b4a5d2f" type="function"/>
+ <keyword name="signal0< T_return, T_accumulator >::signal0" link="classsigc_1_1signal0.html#a7dc687f1afb4088a3d888aa05dbf56d9" type="function"/>
+ <keyword name="signal0< T_return, T_accumulator >::signal0" link="classsigc_1_1signal0.html#ac1b915a86d0b75fd4e90c2a92f7ebc49" type="function"/>
+ <keyword name="signal0< T_return, T_accumulator >::connect" link="classsigc_1_1signal0.html#a609b1e0770f47c9081a3de56b65314d2" type="function"/>
+ <keyword name="signal0< T_return, T_accumulator >::connect" link="classsigc_1_1signal0.html#a9b78954271b6dba5e926bd960f3e7905" type="function"/>
+ <keyword name="signal0< T_return, T_accumulator >::emit" link="classsigc_1_1signal0.html#a655829125186645bcbc61db8252134a8" type="function"/>
+ <keyword name="signal0< T_return, T_accumulator >::emit_reverse" link="classsigc_1_1signal0.html#abdae39f9a7abd6133c03d65224c227d6" type="function"/>
+ <keyword name="signal0< T_return, T_accumulator >::make_slot" link="classsigc_1_1signal0.html#a3295536428e5e0d6478ac10e2daff736" type="function"/>
+ <keyword name="signal0< T_return, T_accumulator >::operator()" link="classsigc_1_1signal0.html#a2dd3042c0681542ed6f2de5840f713a1" type="function"/>
+ <keyword name="signal0< T_return, T_accumulator >::operator=" link="classsigc_1_1signal0.html#a4e8311eac2fd7f8ecd10bff8225ed9e3" type="function"/>
+ <keyword name="signal0< T_return, T_accumulator >::operator=" link="classsigc_1_1signal0.html#a693aa3743236012416349bfac56d31b6" type="function"/>
+ <keyword name="signal0< T_return, T_accumulator >::slots" link="classsigc_1_1signal0.html#a5576113ddfd6b92a96f86072262307f9" type="function"/>
+ <keyword name="signal0< T_return, T_accumulator >::slots" link="classsigc_1_1signal0.html#a73523d71edd7fb4294324e9561db6f3c" type="function"/>
+ <keyword type="struct" name="signal1< T_return, T_arg1, nil >" link="classsigc_1_1signal1.html"/>
+ <keyword name="signal1< T_return, T_arg1, nil >::const_iterator" link="classsigc_1_1signal1.html#af1e262b35c9574e65b2607cdfcaad707" type="typedef"/>
+ <keyword name="signal1< T_return, T_arg1, nil >::const_reverse_iterator" link="classsigc_1_1signal1.html#aeb327519f808dfec9a723511ef82caa3" type="typedef"/>
+ <keyword name="signal1< T_return, T_arg1, nil >::emitter_type" link="classsigc_1_1signal1.html#a63c6e2b55c8c3af083402bb7f5a66593" type="typedef"/>
+ <keyword name="signal1< T_return, T_arg1, nil >::iterator" link="classsigc_1_1signal1.html#ab61e2d1fcaf903dffbb26b01800907fb" type="typedef"/>
+ <keyword name="signal1< T_return, T_arg1, nil >::result_type" link="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1" type="typedef"/>
+ <keyword name="signal1< T_return, T_arg1, nil >::reverse_iterator" link="classsigc_1_1signal1.html#ab0443049aa736d88770d0f534600b2bc" type="typedef"/>
+ <keyword name="signal1< T_return, T_arg1, nil >::slot_list_type" link="classsigc_1_1signal1.html#a5fadeb350140d6aaf560b217e7e7c4b4" type="typedef"/>
+ <keyword name="signal1< T_return, T_arg1, nil >::slot_type" link="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c" type="typedef"/>
+ <keyword name="signal1< T_return, T_arg1, nil >::signal1" link="classsigc_1_1signal1.html#aba62d8d0b9591bcfd728f8ae8a22d600" type="function"/>
+ <keyword name="signal1< T_return, T_arg1, nil >::signal1" link="classsigc_1_1signal1.html#ab3378dd754ffddb4760f2a3afb271dbe" type="function"/>
+ <keyword name="signal1< T_return, T_arg1, nil >::signal1" link="classsigc_1_1signal1.html#a85ec968e0b25ee9285f297da5416b2a4" type="function"/>
+ <keyword name="signal1< T_return, T_arg1, nil >::connect" link="classsigc_1_1signal1.html#aac2ade0896bd4a982777d5dd6ac75888" type="function"/>
+ <keyword name="signal1< T_return, T_arg1, nil >::connect" link="classsigc_1_1signal1.html#ac69d2681c586b310d8c056a319bb65fe" type="function"/>
+ <keyword name="signal1< T_return, T_arg1, nil >::emit" link="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42" type="function"/>
+ <keyword name="signal1< T_return, T_arg1, nil >::emit_reverse" link="classsigc_1_1signal1.html#a449fc940ae822c4b6ea9282b9b292015" type="function"/>
+ <keyword name="signal1< T_return, T_arg1, nil >::make_slot" link="classsigc_1_1signal1.html#a87513117263fd39d5a5a86e0fb8b2a78" type="function"/>
+ <keyword name="signal1< T_return, T_arg1, nil >::operator()" link="classsigc_1_1signal1.html#a828907c11f5c18d9522e5d5139484620" type="function"/>
+ <keyword name="signal1< T_return, T_arg1, nil >::operator=" link="classsigc_1_1signal1.html#a29cd06bf91f96f11c5f29237b8afbb71" type="function"/>
+ <keyword name="signal1< T_return, T_arg1, nil >::operator=" link="classsigc_1_1signal1.html#ab817711d4bc93402d15e87b89a09c364" type="function"/>
+ <keyword name="signal1< T_return, T_arg1, nil >::slots" link="classsigc_1_1signal1.html#a7653b68e6a3b8445de91f89060bf2600" type="function"/>
+ <keyword name="signal1< T_return, T_arg1, nil >::slots" link="classsigc_1_1signal1.html#a7777660b21fef2a6941c7dff23964604" type="function"/>
+ <keyword type="struct" name="signal1< T_return, T_arg1, T_accumulator >" link="classsigc_1_1signal1.html"/>
+ <keyword name="signal1< T_return, T_arg1, T_accumulator >::const_iterator" link="classsigc_1_1signal1.html#af1e262b35c9574e65b2607cdfcaad707" type="typedef"/>
+ <keyword name="signal1< T_return, T_arg1, T_accumulator >::const_reverse_iterator" link="classsigc_1_1signal1.html#aeb327519f808dfec9a723511ef82caa3" type="typedef"/>
+ <keyword name="signal1< T_return, T_arg1, T_accumulator >::emitter_type" link="classsigc_1_1signal1.html#a63c6e2b55c8c3af083402bb7f5a66593" type="typedef"/>
+ <keyword name="signal1< T_return, T_arg1, T_accumulator >::iterator" link="classsigc_1_1signal1.html#ab61e2d1fcaf903dffbb26b01800907fb" type="typedef"/>
+ <keyword name="signal1< T_return, T_arg1, T_accumulator >::result_type" link="classsigc_1_1signal1.html#adcdcfa50d60e1832ce038a4a5554fce1" type="typedef"/>
+ <keyword name="signal1< T_return, T_arg1, T_accumulator >::reverse_iterator" link="classsigc_1_1signal1.html#ab0443049aa736d88770d0f534600b2bc" type="typedef"/>
+ <keyword name="signal1< T_return, T_arg1, T_accumulator >::slot_list_type" link="classsigc_1_1signal1.html#a5fadeb350140d6aaf560b217e7e7c4b4" type="typedef"/>
+ <keyword name="signal1< T_return, T_arg1, T_accumulator >::slot_type" link="classsigc_1_1signal1.html#a310736e1415c2cf4578892ffff35915c" type="typedef"/>
+ <keyword name="signal1< T_return, T_arg1, T_accumulator >::signal1" link="classsigc_1_1signal1.html#aba62d8d0b9591bcfd728f8ae8a22d600" type="function"/>
+ <keyword name="signal1< T_return, T_arg1, T_accumulator >::signal1" link="classsigc_1_1signal1.html#ab3378dd754ffddb4760f2a3afb271dbe" type="function"/>
+ <keyword name="signal1< T_return, T_arg1, T_accumulator >::signal1" link="classsigc_1_1signal1.html#a85ec968e0b25ee9285f297da5416b2a4" type="function"/>
+ <keyword name="signal1< T_return, T_arg1, T_accumulator >::connect" link="classsigc_1_1signal1.html#aac2ade0896bd4a982777d5dd6ac75888" type="function"/>
+ <keyword name="signal1< T_return, T_arg1, T_accumulator >::connect" link="classsigc_1_1signal1.html#ac69d2681c586b310d8c056a319bb65fe" type="function"/>
+ <keyword name="signal1< T_return, T_arg1, T_accumulator >::emit" link="classsigc_1_1signal1.html#affe595f8b70b4f43a21be7192c0cba42" type="function"/>
+ <keyword name="signal1< T_return, T_arg1, T_accumulator >::emit_reverse" link="classsigc_1_1signal1.html#a449fc940ae822c4b6ea9282b9b292015" type="function"/>
+ <keyword name="signal1< T_return, T_arg1, T_accumulator >::make_slot" link="classsigc_1_1signal1.html#a87513117263fd39d5a5a86e0fb8b2a78" type="function"/>
+ <keyword name="signal1< T_return, T_arg1, T_accumulator >::operator()" link="classsigc_1_1signal1.html#a828907c11f5c18d9522e5d5139484620" type="function"/>
+ <keyword name="signal1< T_return, T_arg1, T_accumulator >::operator=" link="classsigc_1_1signal1.html#a29cd06bf91f96f11c5f29237b8afbb71" type="function"/>
+ <keyword name="signal1< T_return, T_arg1, T_accumulator >::operator=" link="classsigc_1_1signal1.html#ab817711d4bc93402d15e87b89a09c364" type="function"/>
+ <keyword name="signal1< T_return, T_arg1, T_accumulator >::slots" link="classsigc_1_1signal1.html#a7653b68e6a3b8445de91f89060bf2600" type="function"/>
+ <keyword name="signal1< T_return, T_arg1, T_accumulator >::slots" link="classsigc_1_1signal1.html#a7777660b21fef2a6941c7dff23964604" type="function"/>
+ <keyword type="struct" name="signal2< T_return, T_arg1, T_arg2, nil >" link="classsigc_1_1signal2.html"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, nil >::const_iterator" link="classsigc_1_1signal2.html#ad507bc5ea29adb2305f8fa91acbd30ee" type="typedef"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, nil >::const_reverse_iterator" link="classsigc_1_1signal2.html#aacb8fe57ffe01dea5c5fb5af44634287" type="typedef"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, nil >::emitter_type" link="classsigc_1_1signal2.html#a01379d580d21de8bc8d0d2d62e6324ea" type="typedef"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, nil >::iterator" link="classsigc_1_1signal2.html#a658ba1c6468882c9b1d480be2bbaf55e" type="typedef"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, nil >::result_type" link="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665" type="typedef"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, nil >::reverse_iterator" link="classsigc_1_1signal2.html#a6710759bdeb8e626fc09d8c448e6613f" type="typedef"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, nil >::slot_list_type" link="classsigc_1_1signal2.html#af31262f54dfb2a97540de9c4a1fc5726" type="typedef"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, nil >::slot_type" link="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119" type="typedef"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, nil >::signal2" link="classsigc_1_1signal2.html#a47aba9b19bc2bef0be7183022567e3ea" type="function"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, nil >::signal2" link="classsigc_1_1signal2.html#aa634515507f2ea4a35584e12e2dc92e7" type="function"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, nil >::signal2" link="classsigc_1_1signal2.html#a20c59f06175d4c48394c65035d2c3376" type="function"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, nil >::connect" link="classsigc_1_1signal2.html#aa686af4f961b098a23d4f7276437c2b0" type="function"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, nil >::connect" link="classsigc_1_1signal2.html#ab89b1876c69ea40954b0af37e75a21b4" type="function"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, nil >::emit" link="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f" type="function"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, nil >::emit_reverse" link="classsigc_1_1signal2.html#ad2d5f3169ba147de8d43fde9e93bac98" type="function"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, nil >::make_slot" link="classsigc_1_1signal2.html#a844d15c61c83933575e7953b29365efa" type="function"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, nil >::operator()" link="classsigc_1_1signal2.html#ac8b73c0624273b8dae819255961ea6a3" type="function"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, nil >::operator=" link="classsigc_1_1signal2.html#abeb05d9a2b40882bad753fccad6522be" type="function"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, nil >::operator=" link="classsigc_1_1signal2.html#a5d3f71fb9ee8754c4640fb5bfb954151" type="function"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, nil >::slots" link="classsigc_1_1signal2.html#ac28b0205aa1e60cc5ce062d4d8545323" type="function"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, nil >::slots" link="classsigc_1_1signal2.html#aa6be4804147afd56657abf5b4cf8ce3d" type="function"/>
+ <keyword type="struct" name="signal2< T_return, T_arg1, T_arg2, T_accumulator >" link="classsigc_1_1signal2.html"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, T_accumulator >::const_iterator" link="classsigc_1_1signal2.html#ad507bc5ea29adb2305f8fa91acbd30ee" type="typedef"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, T_accumulator >::const_reverse_iterator" link="classsigc_1_1signal2.html#aacb8fe57ffe01dea5c5fb5af44634287" type="typedef"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, T_accumulator >::emitter_type" link="classsigc_1_1signal2.html#a01379d580d21de8bc8d0d2d62e6324ea" type="typedef"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, T_accumulator >::iterator" link="classsigc_1_1signal2.html#a658ba1c6468882c9b1d480be2bbaf55e" type="typedef"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, T_accumulator >::result_type" link="classsigc_1_1signal2.html#a55151695417c33540357ff524bfe2665" type="typedef"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, T_accumulator >::reverse_iterator" link="classsigc_1_1signal2.html#a6710759bdeb8e626fc09d8c448e6613f" type="typedef"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, T_accumulator >::slot_list_type" link="classsigc_1_1signal2.html#af31262f54dfb2a97540de9c4a1fc5726" type="typedef"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, T_accumulator >::slot_type" link="classsigc_1_1signal2.html#af7797ae10e76307f8d230588e760f119" type="typedef"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, T_accumulator >::signal2" link="classsigc_1_1signal2.html#a47aba9b19bc2bef0be7183022567e3ea" type="function"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, T_accumulator >::signal2" link="classsigc_1_1signal2.html#aa634515507f2ea4a35584e12e2dc92e7" type="function"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, T_accumulator >::signal2" link="classsigc_1_1signal2.html#a20c59f06175d4c48394c65035d2c3376" type="function"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, T_accumulator >::connect" link="classsigc_1_1signal2.html#aa686af4f961b098a23d4f7276437c2b0" type="function"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, T_accumulator >::connect" link="classsigc_1_1signal2.html#ab89b1876c69ea40954b0af37e75a21b4" type="function"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, T_accumulator >::emit" link="classsigc_1_1signal2.html#afd12e2a266a6399cc32e888d6f5e6f2f" type="function"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, T_accumulator >::emit_reverse" link="classsigc_1_1signal2.html#ad2d5f3169ba147de8d43fde9e93bac98" type="function"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, T_accumulator >::make_slot" link="classsigc_1_1signal2.html#a844d15c61c83933575e7953b29365efa" type="function"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, T_accumulator >::operator()" link="classsigc_1_1signal2.html#ac8b73c0624273b8dae819255961ea6a3" type="function"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, T_accumulator >::operator=" link="classsigc_1_1signal2.html#abeb05d9a2b40882bad753fccad6522be" type="function"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, T_accumulator >::operator=" link="classsigc_1_1signal2.html#a5d3f71fb9ee8754c4640fb5bfb954151" type="function"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, T_accumulator >::slots" link="classsigc_1_1signal2.html#ac28b0205aa1e60cc5ce062d4d8545323" type="function"/>
+ <keyword name="signal2< T_return, T_arg1, T_arg2, T_accumulator >::slots" link="classsigc_1_1signal2.html#aa6be4804147afd56657abf5b4cf8ce3d" type="function"/>
+ <keyword type="struct" name="signal3< T_return, T_arg1, T_arg2, T_arg3, nil >" link="classsigc_1_1signal3.html"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, nil >::const_iterator" link="classsigc_1_1signal3.html#a60e1ef95f82cd8981d61576d1e3f8e94" type="typedef"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, nil >::const_reverse_iterator" link="classsigc_1_1signal3.html#a4ba3eb58c4c5ac2c25f49c48fd0af264" type="typedef"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, nil >::emitter_type" link="classsigc_1_1signal3.html#adf54ec96c5fb78d4c8b7fc032a1937ad" type="typedef"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, nil >::iterator" link="classsigc_1_1signal3.html#a8029a48126a2018947a2b6680ddabe6b" type="typedef"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, nil >::result_type" link="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6" type="typedef"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, nil >::reverse_iterator" link="classsigc_1_1signal3.html#acc453f0d5fc7f277494b2d6e737f6f68" type="typedef"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, nil >::slot_list_type" link="classsigc_1_1signal3.html#a3bc0616e7ac933e702a889a2a84e92d4" type="typedef"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, nil >::slot_type" link="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b" type="typedef"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, nil >::signal3" link="classsigc_1_1signal3.html#a52731959f272612fd6abfe8850c5c8cf" type="function"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, nil >::signal3" link="classsigc_1_1signal3.html#afe2c4320927b403b011a2538317e6c70" type="function"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, nil >::signal3" link="classsigc_1_1signal3.html#acd69c2a1d993f0b8993f82998f76020d" type="function"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, nil >::connect" link="classsigc_1_1signal3.html#a3eae0b3796b2736be847f33a5124aacd" type="function"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, nil >::connect" link="classsigc_1_1signal3.html#ad71389c6d6ea60e745897579b3344d00" type="function"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, nil >::emit" link="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb" type="function"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, nil >::emit_reverse" link="classsigc_1_1signal3.html#a97ff4f22c97920a81e3f27aa5d39ba99" type="function"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, nil >::make_slot" link="classsigc_1_1signal3.html#a332be8eb0ee22c11a2e1d140ca1bc2df" type="function"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, nil >::operator()" link="classsigc_1_1signal3.html#aa7ae5338d6a883a28c61ff202e43547f" type="function"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, nil >::operator=" link="classsigc_1_1signal3.html#a0c398a25051e920bc4338f35b4bf7df6" type="function"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, nil >::operator=" link="classsigc_1_1signal3.html#abafd9fe17f2b9b18e25eb0293e9e8bfd" type="function"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, nil >::slots" link="classsigc_1_1signal3.html#ab9606b708078956a758b81503f956bee" type="function"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, nil >::slots" link="classsigc_1_1signal3.html#a742eb282312187bf8ee6992df1114781" type="function"/>
+ <keyword type="struct" name="signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >" link="classsigc_1_1signal3.html"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::const_iterator" link="classsigc_1_1signal3.html#a60e1ef95f82cd8981d61576d1e3f8e94" type="typedef"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::const_reverse_iterator" link="classsigc_1_1signal3.html#a4ba3eb58c4c5ac2c25f49c48fd0af264" type="typedef"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::emitter_type" link="classsigc_1_1signal3.html#adf54ec96c5fb78d4c8b7fc032a1937ad" type="typedef"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::iterator" link="classsigc_1_1signal3.html#a8029a48126a2018947a2b6680ddabe6b" type="typedef"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::result_type" link="classsigc_1_1signal3.html#a57c79755fc4c4b04196a9bf6742a0cc6" type="typedef"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::reverse_iterator" link="classsigc_1_1signal3.html#acc453f0d5fc7f277494b2d6e737f6f68" type="typedef"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::slot_list_type" link="classsigc_1_1signal3.html#a3bc0616e7ac933e702a889a2a84e92d4" type="typedef"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::slot_type" link="classsigc_1_1signal3.html#afe37478128b40fb4efedcd3c0eb05b6b" type="typedef"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::signal3" link="classsigc_1_1signal3.html#a52731959f272612fd6abfe8850c5c8cf" type="function"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::signal3" link="classsigc_1_1signal3.html#afe2c4320927b403b011a2538317e6c70" type="function"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::signal3" link="classsigc_1_1signal3.html#acd69c2a1d993f0b8993f82998f76020d" type="function"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::connect" link="classsigc_1_1signal3.html#a3eae0b3796b2736be847f33a5124aacd" type="function"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::connect" link="classsigc_1_1signal3.html#ad71389c6d6ea60e745897579b3344d00" type="function"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::emit" link="classsigc_1_1signal3.html#a8592e22e3780f2cdf19a568a8a116bbb" type="function"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::emit_reverse" link="classsigc_1_1signal3.html#a97ff4f22c97920a81e3f27aa5d39ba99" type="function"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::make_slot" link="classsigc_1_1signal3.html#a332be8eb0ee22c11a2e1d140ca1bc2df" type="function"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::operator()" link="classsigc_1_1signal3.html#aa7ae5338d6a883a28c61ff202e43547f" type="function"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::operator=" link="classsigc_1_1signal3.html#a0c398a25051e920bc4338f35b4bf7df6" type="function"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::operator=" link="classsigc_1_1signal3.html#abafd9fe17f2b9b18e25eb0293e9e8bfd" type="function"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::slots" link="classsigc_1_1signal3.html#ab9606b708078956a758b81503f956bee" type="function"/>
+ <keyword name="signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator >::slots" link="classsigc_1_1signal3.html#a742eb282312187bf8ee6992df1114781" type="function"/>
+ <keyword type="struct" name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil >" link="classsigc_1_1signal4.html"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil >::const_iterator" link="classsigc_1_1signal4.html#a3d2626edc726047c04c8fe5b9824b958" type="typedef"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil >::const_reverse_iterator" link="classsigc_1_1signal4.html#a555ce030884fdf2bde788b75db01bedf" type="typedef"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil >::emitter_type" link="classsigc_1_1signal4.html#acf3d1e6d6487c0ecc13ed3eab949eec7" type="typedef"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil >::iterator" link="classsigc_1_1signal4.html#a31e8354263a3097bba9c63b8494143f0" type="typedef"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil >::result_type" link="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0" type="typedef"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil >::reverse_iterator" link="classsigc_1_1signal4.html#a1395da7d3283b0166af135193a4047c8" type="typedef"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil >::slot_list_type" link="classsigc_1_1signal4.html#a0ad0f56a43825c6d77d36dd2f06ef828" type="typedef"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil >::slot_type" link="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c" type="typedef"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil >::signal4" link="classsigc_1_1signal4.html#a2d469f516a9edac2b20d7f6cf46e821a" type="function"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil >::signal4" link="classsigc_1_1signal4.html#a2d29b39c12c6c014ed7166190e9c8e22" type="function"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil >::signal4" link="classsigc_1_1signal4.html#a2197974bac2b5e8e7b1c417580686e9e" type="function"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil >::connect" link="classsigc_1_1signal4.html#a5fdb6df3cf74f5c96fb6319eef4d0a39" type="function"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil >::connect" link="classsigc_1_1signal4.html#a5c8d2d9c91a134650a52631d49ecdaac" type="function"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil >::emit" link="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef" type="function"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil >::emit_reverse" link="classsigc_1_1signal4.html#a0aaf27875cdb8a0ae381372d98871ae1" type="function"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil >::make_slot" link="classsigc_1_1signal4.html#aebcf1389e689b8d43ff739df118482bc" type="function"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil >::operator()" link="classsigc_1_1signal4.html#a8523a4d47c3a6469fcc50da9977afdb8" type="function"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil >::operator=" link="classsigc_1_1signal4.html#a05908db9c09a9c513529cd8b2106f913" type="function"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil >::operator=" link="classsigc_1_1signal4.html#ab21da01af7c724bf0cf9df35ee9a70c1" type="function"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil >::slots" link="classsigc_1_1signal4.html#ae490f1a6802c40a4c3b12e1580520c88" type="function"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil >::slots" link="classsigc_1_1signal4.html#a35f2cebe3804d3e04d3253b7cc8d2a72" type="function"/>
+ <keyword type="struct" name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >" link="classsigc_1_1signal4.html"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::const_iterator" link="classsigc_1_1signal4.html#a3d2626edc726047c04c8fe5b9824b958" type="typedef"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::const_reverse_iterator" link="classsigc_1_1signal4.html#a555ce030884fdf2bde788b75db01bedf" type="typedef"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::emitter_type" link="classsigc_1_1signal4.html#acf3d1e6d6487c0ecc13ed3eab949eec7" type="typedef"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::iterator" link="classsigc_1_1signal4.html#a31e8354263a3097bba9c63b8494143f0" type="typedef"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::result_type" link="classsigc_1_1signal4.html#af32418ba14001a63d28af08abb7407f0" type="typedef"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::reverse_iterator" link="classsigc_1_1signal4.html#a1395da7d3283b0166af135193a4047c8" type="typedef"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::slot_list_type" link="classsigc_1_1signal4.html#a0ad0f56a43825c6d77d36dd2f06ef828" type="typedef"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::slot_type" link="classsigc_1_1signal4.html#aa93452fe80399184444d094786be851c" type="typedef"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::signal4" link="classsigc_1_1signal4.html#a2d469f516a9edac2b20d7f6cf46e821a" type="function"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::signal4" link="classsigc_1_1signal4.html#a2d29b39c12c6c014ed7166190e9c8e22" type="function"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::signal4" link="classsigc_1_1signal4.html#a2197974bac2b5e8e7b1c417580686e9e" type="function"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::connect" link="classsigc_1_1signal4.html#a5fdb6df3cf74f5c96fb6319eef4d0a39" type="function"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::connect" link="classsigc_1_1signal4.html#a5c8d2d9c91a134650a52631d49ecdaac" type="function"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::emit" link="classsigc_1_1signal4.html#aa7774ba75b5e2391a6fe2841f8b3b0ef" type="function"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::emit_reverse" link="classsigc_1_1signal4.html#a0aaf27875cdb8a0ae381372d98871ae1" type="function"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::make_slot" link="classsigc_1_1signal4.html#aebcf1389e689b8d43ff739df118482bc" type="function"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::operator()" link="classsigc_1_1signal4.html#a8523a4d47c3a6469fcc50da9977afdb8" type="function"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::operator=" link="classsigc_1_1signal4.html#a05908db9c09a9c513529cd8b2106f913" type="function"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::operator=" link="classsigc_1_1signal4.html#ab21da01af7c724bf0cf9df35ee9a70c1" type="function"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::slots" link="classsigc_1_1signal4.html#ae490f1a6802c40a4c3b12e1580520c88" type="function"/>
+ <keyword name="signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator >::slots" link="classsigc_1_1signal4.html#a35f2cebe3804d3e04d3253b7cc8d2a72" type="function"/>
+ <keyword type="struct" name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil >" link="classsigc_1_1signal5.html"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil >::const_iterator" link="classsigc_1_1signal5.html#a17e79eed46f178a12d2751eddcf85290" type="typedef"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil >::const_reverse_iterator" link="classsigc_1_1signal5.html#ad5ba46907fe236e0cff806888696d569" type="typedef"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil >::emitter_type" link="classsigc_1_1signal5.html#a7d77e5fa748b024842bf92e28cf0f4ab" type="typedef"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil >::iterator" link="classsigc_1_1signal5.html#acee689b441305fcee098345729fc28f3" type="typedef"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil >::result_type" link="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94" type="typedef"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil >::reverse_iterator" link="classsigc_1_1signal5.html#ab684cb9920d0f7949f28c03d50b58275" type="typedef"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil >::slot_list_type" link="classsigc_1_1signal5.html#a4c79ab227fc3b31b990e925636f7788e" type="typedef"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil >::slot_type" link="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e" type="typedef"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil >::signal5" link="classsigc_1_1signal5.html#af717d1a6fd8612da84dce33fe6640b7a" type="function"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil >::signal5" link="classsigc_1_1signal5.html#a7885861b9cdbacbe2d58a13cd96ec265" type="function"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil >::signal5" link="classsigc_1_1signal5.html#af39141aeec9dc870dd28926202493de4" type="function"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil >::connect" link="classsigc_1_1signal5.html#a057789cc27a920700e240f8f3d78dd65" type="function"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil >::connect" link="classsigc_1_1signal5.html#a05cfed3d3e29158424bc810168d78153" type="function"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil >::emit" link="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" type="function"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil >::emit_reverse" link="classsigc_1_1signal5.html#aa6d2e202263e3879f0d3949612d7fcdf" type="function"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil >::make_slot" link="classsigc_1_1signal5.html#a7b01481c87d4ec9c03095e76cb502c24" type="function"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil >::operator()" link="classsigc_1_1signal5.html#a7a5bb7b92f49e99354caf50bfef16907" type="function"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil >::operator=" link="classsigc_1_1signal5.html#a2c3d9a6d8b499da389672f44f8044ce6" type="function"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil >::operator=" link="classsigc_1_1signal5.html#a5c652f8e549a2c555b79db8e8a05f407" type="function"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil >::slots" link="classsigc_1_1signal5.html#ad6a4ae2a214d8710be6e36bb425587fc" type="function"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil >::slots" link="classsigc_1_1signal5.html#a32af276c9c56abbb0386f54262b40be5" type="function"/>
+ <keyword type="struct" name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >" link="classsigc_1_1signal5.html"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::const_iterator" link="classsigc_1_1signal5.html#a17e79eed46f178a12d2751eddcf85290" type="typedef"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::const_reverse_iterator" link="classsigc_1_1signal5.html#ad5ba46907fe236e0cff806888696d569" type="typedef"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::emitter_type" link="classsigc_1_1signal5.html#a7d77e5fa748b024842bf92e28cf0f4ab" type="typedef"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::iterator" link="classsigc_1_1signal5.html#acee689b441305fcee098345729fc28f3" type="typedef"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::result_type" link="classsigc_1_1signal5.html#aceb959897dcf8e3c7209c283d4848b94" type="typedef"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::reverse_iterator" link="classsigc_1_1signal5.html#ab684cb9920d0f7949f28c03d50b58275" type="typedef"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::slot_list_type" link="classsigc_1_1signal5.html#a4c79ab227fc3b31b990e925636f7788e" type="typedef"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::slot_type" link="classsigc_1_1signal5.html#ae73737aad5d854c6466e8b13e7963b9e" type="typedef"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::signal5" link="classsigc_1_1signal5.html#af717d1a6fd8612da84dce33fe6640b7a" type="function"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::signal5" link="classsigc_1_1signal5.html#a7885861b9cdbacbe2d58a13cd96ec265" type="function"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::signal5" link="classsigc_1_1signal5.html#af39141aeec9dc870dd28926202493de4" type="function"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::connect" link="classsigc_1_1signal5.html#a057789cc27a920700e240f8f3d78dd65" type="function"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::connect" link="classsigc_1_1signal5.html#a05cfed3d3e29158424bc810168d78153" type="function"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::emit" link="classsigc_1_1signal5.html#a8772fef879632c4ff45e82b4b00b0157" type="function"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::emit_reverse" link="classsigc_1_1signal5.html#aa6d2e202263e3879f0d3949612d7fcdf" type="function"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::make_slot" link="classsigc_1_1signal5.html#a7b01481c87d4ec9c03095e76cb502c24" type="function"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::operator()" link="classsigc_1_1signal5.html#a7a5bb7b92f49e99354caf50bfef16907" type="function"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::operator=" link="classsigc_1_1signal5.html#a2c3d9a6d8b499da389672f44f8044ce6" type="function"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::operator=" link="classsigc_1_1signal5.html#a5c652f8e549a2c555b79db8e8a05f407" type="function"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::slots" link="classsigc_1_1signal5.html#ad6a4ae2a214d8710be6e36bb425587fc" type="function"/>
+ <keyword name="signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator >::slots" link="classsigc_1_1signal5.html#a32af276c9c56abbb0386f54262b40be5" type="function"/>
+ <keyword type="struct" name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >" link="classsigc_1_1signal6.html"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::const_iterator" link="classsigc_1_1signal6.html#ac88a9c4e9bab5ad04c66d3f5d3978f0f" type="typedef"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::const_reverse_iterator" link="classsigc_1_1signal6.html#aff490e7f75a83aa2f324a859f9071a79" type="typedef"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::emitter_type" link="classsigc_1_1signal6.html#acdd2683223e4701f58350152f32f4488" type="typedef"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::iterator" link="classsigc_1_1signal6.html#a1acee11287974cdac1bc63c856e5331d" type="typedef"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::result_type" link="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f" type="typedef"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::reverse_iterator" link="classsigc_1_1signal6.html#a79b741b3f0def8f52fc185ad50b60673" type="typedef"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::slot_list_type" link="classsigc_1_1signal6.html#a0e4fea9bd1ed35f9d60bbc26c4fae007" type="typedef"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::slot_type" link="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db" type="typedef"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::signal6" link="classsigc_1_1signal6.html#af7f529bbd9cf26d468ed18426b9b51ea" type="function"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::signal6" link="classsigc_1_1signal6.html#a0244dde296bd892c590c86ced5281e3b" type="function"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::signal6" link="classsigc_1_1signal6.html#ab717ce413bda79e1de41944d0675a8ca" type="function"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::connect" link="classsigc_1_1signal6.html#a66c302607cf4fb74f5d3352f9c394c9b" type="function"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::connect" link="classsigc_1_1signal6.html#a1754aa5a8959da0bb55e42864a8365af" type="function"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::emit" link="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" type="function"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::emit_reverse" link="classsigc_1_1signal6.html#a2e8b355902f0646fb34b52b495123167" type="function"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::make_slot" link="classsigc_1_1signal6.html#a97ae4180e80ac60b564fec58d1732317" type="function"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::operator()" link="classsigc_1_1signal6.html#affec011fd6e9605f10e50fdd4db424d8" type="function"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::operator=" link="classsigc_1_1signal6.html#ad7a4ab249b17bffccbfe441aa1420dd9" type="function"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::operator=" link="classsigc_1_1signal6.html#a012b9abce888e420e1b5b3f29aa98900" type="function"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::slots" link="classsigc_1_1signal6.html#af44115a7bfa4586fc5312259a1df9567" type="function"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::slots" link="classsigc_1_1signal6.html#ac66109f683ae86898ae10109a80b28a4" type="function"/>
+ <keyword type="struct" name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >" link="classsigc_1_1signal6.html"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::const_iterator" link="classsigc_1_1signal6.html#ac88a9c4e9bab5ad04c66d3f5d3978f0f" type="typedef"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::const_reverse_iterator" link="classsigc_1_1signal6.html#aff490e7f75a83aa2f324a859f9071a79" type="typedef"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::emitter_type" link="classsigc_1_1signal6.html#acdd2683223e4701f58350152f32f4488" type="typedef"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::iterator" link="classsigc_1_1signal6.html#a1acee11287974cdac1bc63c856e5331d" type="typedef"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::result_type" link="classsigc_1_1signal6.html#a56f1acca230e676dae665d41a10acc8f" type="typedef"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::reverse_iterator" link="classsigc_1_1signal6.html#a79b741b3f0def8f52fc185ad50b60673" type="typedef"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::slot_list_type" link="classsigc_1_1signal6.html#a0e4fea9bd1ed35f9d60bbc26c4fae007" type="typedef"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::slot_type" link="classsigc_1_1signal6.html#ac62cdf4db7dcd5e30975e51e978f03db" type="typedef"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::signal6" link="classsigc_1_1signal6.html#af7f529bbd9cf26d468ed18426b9b51ea" type="function"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::signal6" link="classsigc_1_1signal6.html#a0244dde296bd892c590c86ced5281e3b" type="function"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::signal6" link="classsigc_1_1signal6.html#ab717ce413bda79e1de41944d0675a8ca" type="function"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::connect" link="classsigc_1_1signal6.html#a66c302607cf4fb74f5d3352f9c394c9b" type="function"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::connect" link="classsigc_1_1signal6.html#a1754aa5a8959da0bb55e42864a8365af" type="function"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::emit" link="classsigc_1_1signal6.html#a6361a9230323e7c7e86e2c9e6c8fe21b" type="function"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::emit_reverse" link="classsigc_1_1signal6.html#a2e8b355902f0646fb34b52b495123167" type="function"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::make_slot" link="classsigc_1_1signal6.html#a97ae4180e80ac60b564fec58d1732317" type="function"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::operator()" link="classsigc_1_1signal6.html#affec011fd6e9605f10e50fdd4db424d8" type="function"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::operator=" link="classsigc_1_1signal6.html#ad7a4ab249b17bffccbfe441aa1420dd9" type="function"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::operator=" link="classsigc_1_1signal6.html#a012b9abce888e420e1b5b3f29aa98900" type="function"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::slots" link="classsigc_1_1signal6.html#af44115a7bfa4586fc5312259a1df9567" type="function"/>
+ <keyword name="signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator >::slots" link="classsigc_1_1signal6.html#ac66109f683ae86898ae10109a80b28a4" type="function"/>
+ <keyword type="struct" name="signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil >" link="classsigc_1_1signal7.html"/>
+ <keyword name="signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil >::const_iterator" link="classsigc_1_1signal7.html#a6eef6225eba66a86dd32c3f3b79845f7" type="typedef"/>
+ <keyword name="signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil >::const_reverse_iterator" link="classsigc_1_1signal7.html#ad1ba32ad7dae0c05a4012ada78077505" type="typedef"/>
+ <keyword name="signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil >::emitter_type" link="classsigc_1_1signal7.html#a7fa856e67a31c86538db7c289a6870e3" type="typedef"/>
+ <keyword name="signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil >::iterator" link="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a" type="typedef"/>
+ <keyword name="signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil >::result_type" link="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f" type="typedef"/>
+ <keyword name="signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil >::reverse_iterator" link="classsigc_1_1signal7.html#a59c9c9fee7a98528839df592241351a9" type="typedef"/>
+ <keyword name="signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil >::slot_list_type" link="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003" type="typedef"/>
+ <keyword name="signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil >::slot_type" link="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81" type="typedef"/>
+ <keyword name="signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil >::signal7" link="classsigc_1_1signal7.html#ab6d54db53a164fb459fcb342d4b45ff0" type="function"/>
+ <keyword name="signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil >::signal7" link="classsigc_1_1signal7.html#a12d6e064d0a5c2a8c09d60a64184a823" type="function"/>
+ <keyword name="signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil >::signal7" link="classsigc_1_1signal7.html#a5a5893dd4f97d77b7945819f5ada2aee" type="function"/>
+ <keyword name="signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil >::connect" link="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2" type="function"/>
+ <keyword name="signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil >::connect" link="classsigc_1_1signal7.html#a5aed4bdb8d85c3d854f01410d2d9d3a4" type="function"/>
+ <keyword name="signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil >::emit" link="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" type="function"/>
+ <keyword name="signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil >::emit_reverse" link="classsigc_1_1signal7.html#a192581feb2dbcfc9c56692e72e91e9a8" type="function"/>
+ <keyword name="signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil >::make_slot" link="classsigc_1_1signal7.html#a3f468c8b6cc55d675c75d0184bd8e38a" type="function"/>
+ <keyword name="signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil >::operator()" link="classsigc_1_1signal7.html#ac6fd43215c8f19082402387359330071" type="function"/>
+ <keyword name="signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil >::operator=" link="classsigc_1_1signal7.html#af8a93a4c8fb0b78fa6578e7dc95f5751" type="function"/>
+ <keyword name="signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil >::operator=" link="classsigc_1_1signal7.html#ac06938f5cb6ff60a1bd5eaa32c990eea" type="function"/>
+ <keyword name="signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil >::slots" link="classsigc_1_1signal7.html#a68153d9079b4881352113079cd6216f7" type="function"/>
+ <keyword name="signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil >::slots" link="classsigc_1_1signal7.html#a42509108239296e424844df2cd330aca" type="function"/>
+ <keyword type="struct" name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil >" link="classsigc_1_1signal7.html"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil >::const_iterator" link="classsigc_1_1signal7.html#a6eef6225eba66a86dd32c3f3b79845f7" type="typedef"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil >::const_reverse_iterator" link="classsigc_1_1signal7.html#ad1ba32ad7dae0c05a4012ada78077505" type="typedef"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil >::emitter_type" link="classsigc_1_1signal7.html#a7fa856e67a31c86538db7c289a6870e3" type="typedef"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil >::iterator" link="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a" type="typedef"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil >::result_type" link="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f" type="typedef"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil >::reverse_iterator" link="classsigc_1_1signal7.html#a59c9c9fee7a98528839df592241351a9" type="typedef"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil >::slot_list_type" link="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003" type="typedef"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil >::slot_type" link="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81" type="typedef"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil >::signal7" link="classsigc_1_1signal7.html#ab6d54db53a164fb459fcb342d4b45ff0" type="function"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil >::signal7" link="classsigc_1_1signal7.html#a12d6e064d0a5c2a8c09d60a64184a823" type="function"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil >::signal7" link="classsigc_1_1signal7.html#a5a5893dd4f97d77b7945819f5ada2aee" type="function"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil >::connect" link="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2" type="function"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil >::connect" link="classsigc_1_1signal7.html#a5aed4bdb8d85c3d854f01410d2d9d3a4" type="function"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil >::emit" link="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" type="function"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil >::emit_reverse" link="classsigc_1_1signal7.html#a192581feb2dbcfc9c56692e72e91e9a8" type="function"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil >::make_slot" link="classsigc_1_1signal7.html#a3f468c8b6cc55d675c75d0184bd8e38a" type="function"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil >::operator()" link="classsigc_1_1signal7.html#ac6fd43215c8f19082402387359330071" type="function"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil >::operator=" link="classsigc_1_1signal7.html#af8a93a4c8fb0b78fa6578e7dc95f5751" type="function"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil >::operator=" link="classsigc_1_1signal7.html#ac06938f5cb6ff60a1bd5eaa32c990eea" type="function"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil >::slots" link="classsigc_1_1signal7.html#a68153d9079b4881352113079cd6216f7" type="function"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil >::slots" link="classsigc_1_1signal7.html#a42509108239296e424844df2cd330aca" type="function"/>
+ <keyword type="struct" name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >" link="classsigc_1_1signal7.html"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::const_iterator" link="classsigc_1_1signal7.html#a6eef6225eba66a86dd32c3f3b79845f7" type="typedef"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::const_reverse_iterator" link="classsigc_1_1signal7.html#ad1ba32ad7dae0c05a4012ada78077505" type="typedef"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::emitter_type" link="classsigc_1_1signal7.html#a7fa856e67a31c86538db7c289a6870e3" type="typedef"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::iterator" link="classsigc_1_1signal7.html#abc62e52cc684f917577a2fe3cd914d4a" type="typedef"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::result_type" link="classsigc_1_1signal7.html#a5a75d73a254cf91a0f3ad1cd3545e29f" type="typedef"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::reverse_iterator" link="classsigc_1_1signal7.html#a59c9c9fee7a98528839df592241351a9" type="typedef"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::slot_list_type" link="classsigc_1_1signal7.html#a79686c2174ab01dc23394953955ff003" type="typedef"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::slot_type" link="classsigc_1_1signal7.html#a72ee8c51eea3d1ba99eb9b512dfccd81" type="typedef"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::signal7" link="classsigc_1_1signal7.html#ab6d54db53a164fb459fcb342d4b45ff0" type="function"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::signal7" link="classsigc_1_1signal7.html#a12d6e064d0a5c2a8c09d60a64184a823" type="function"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::signal7" link="classsigc_1_1signal7.html#a5a5893dd4f97d77b7945819f5ada2aee" type="function"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::connect" link="classsigc_1_1signal7.html#adc55ac9b0f935fd87a67904022e03cb2" type="function"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::connect" link="classsigc_1_1signal7.html#a5aed4bdb8d85c3d854f01410d2d9d3a4" type="function"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::emit" link="classsigc_1_1signal7.html#aead3b0e97ed0bd95f870b1956bff83c2" type="function"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::emit_reverse" link="classsigc_1_1signal7.html#a192581feb2dbcfc9c56692e72e91e9a8" type="function"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::make_slot" link="classsigc_1_1signal7.html#a3f468c8b6cc55d675c75d0184bd8e38a" type="function"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::operator()" link="classsigc_1_1signal7.html#ac6fd43215c8f19082402387359330071" type="function"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::operator=" link="classsigc_1_1signal7.html#af8a93a4c8fb0b78fa6578e7dc95f5751" type="function"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::operator=" link="classsigc_1_1signal7.html#ac06938f5cb6ff60a1bd5eaa32c990eea" type="function"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::slots" link="classsigc_1_1signal7.html#a68153d9079b4881352113079cd6216f7" type="function"/>
+ <keyword name="signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator >::slots" link="classsigc_1_1signal7.html#a42509108239296e424844df2cd330aca" type="function"/>
+ <keyword type="struct" name="slot7< T_return, nil, nil, nil, nil, nil, nil, nil >" link="classsigc_1_1slot7.html"/>
+ <keyword name="slot7< T_return, nil, nil, nil, nil, nil, nil, nil >::arg1_type_" link="classsigc_1_1slot7.html#a58edf93a837003d1a69fc77d39fc11a9" type="typedef"/>
+ <keyword name="slot7< T_return, nil, nil, nil, nil, nil, nil, nil >::arg2_type_" link="classsigc_1_1slot7.html#ad144d8ea3ecb891d358b5b1b969be7e2" type="typedef"/>
+ <keyword name="slot7< T_return, nil, nil, nil, nil, nil, nil, nil >::arg3_type_" link="classsigc_1_1slot7.html#af90cd5954008a84d6459d99de152a08c" type="typedef"/>
+ <keyword name="slot7< T_return, nil, nil, nil, nil, nil, nil, nil >::arg4_type_" link="classsigc_1_1slot7.html#af42bc9af248b7c2226d93230bd7b1024" type="typedef"/>
+ <keyword name="slot7< T_return, nil, nil, nil, nil, nil, nil, nil >::arg5_type_" link="classsigc_1_1slot7.html#ad6c1006a29f6fcb721bc39e8d6f82323" type="typedef"/>
+ <keyword name="slot7< T_return, nil, nil, nil, nil, nil, nil, nil >::arg6_type_" link="classsigc_1_1slot7.html#ae25a8a8663addfce52415a20725a3b3e" type="typedef"/>
+ <keyword name="slot7< T_return, nil, nil, nil, nil, nil, nil, nil >::arg7_type_" link="classsigc_1_1slot7.html#a2dc6c96b8d014fab9daea823188ca021" type="typedef"/>
+ <keyword name="slot7< T_return, nil, nil, nil, nil, nil, nil, nil >::result_type" link="classsigc_1_1slot7.html#a06a374d3304636cb48fed29542dc851f" type="typedef"/>
+ <keyword name="slot7< T_return, nil, nil, nil, nil, nil, nil, nil >::slot7" link="classsigc_1_1slot7.html#abf200ae4152fb26fc96a6863be3548b8" type="function"/>
+ <keyword name="slot7< T_return, nil, nil, nil, nil, nil, nil, nil >::slot7" link="classsigc_1_1slot7.html#a6411349bb6f8d7151f41ae7772e61f6d" type="function"/>
+ <keyword name="slot7< T_return, nil, nil, nil, nil, nil, nil, nil >::slot7" link="classsigc_1_1slot7.html#aa9b64dc6516b8a0d55f46e4737eaaf8b" type="function"/>
+ <keyword name="slot7< T_return, nil, nil, nil, nil, nil, nil, nil >::slot7" link="classsigc_1_1slot7.html#a69a267bb61931f4ea039048d3221517c" type="function"/>
+ <keyword name="slot7< T_return, nil, nil, nil, nil, nil, nil, nil >::operator()" link="classsigc_1_1slot7.html#a28e18e1a9adc88a4758be7d2497fc88d" type="function"/>
+ <keyword name="slot7< T_return, nil, nil, nil, nil, nil, nil, nil >::operator=" link="classsigc_1_1slot7.html#af6bf09a0b3c09245257af113e70269d2" type="function"/>
+ <keyword name="slot7< T_return, nil, nil, nil, nil, nil, nil, nil >::operator=" link="classsigc_1_1slot7.html#a82b499c48909c51c4dad097885804638" type="function"/>
+ <keyword type="struct" name="volatile_limit_reference< T_obj >" link="classsigc_1_1volatile__limit__reference.html"/>
+ <keyword name="volatile_limit_reference< T_obj >::volatile_limit_reference" link="classsigc_1_1volatile__limit__reference.html#acb3e6e1ecc628343f94faae718b58066" type="function"/>
+ <keyword name="volatile_limit_reference< T_obj >::invoke" link="classsigc_1_1volatile__limit__reference.html#a0157cc89d9db4032c7a8f9159ebaeff3" type="function"/>
+ <keyword name="volatile_limit_reference< T_obj >::visit" link="classsigc_1_1volatile__limit__reference.html#a4d67fe2d9d27c326136a9e5ac13a1a75" type="function"/>
+ <keyword name="sigc::deduce_result_t" link="namespacesigc.html#ab7791439fb79592300826fe076a8e3d1" type="typedef"/>
+ <keyword name="sigc::type_trait_pass_t" link="namespacesigc.html#aa2d13c7fc829cfec6e0f9d5092f2aa79" type="typedef"/>
+ <keyword name="sigc::type_trait_take_t" link="namespacesigc.html#aa0d56c61023af35c47b79db80b32fd2e" type="typedef"/>
+ <keyword name="sigc::bind" link="group__bind.html#ga2f099bc6056b32f2a58134ba8537c6f4" type="function"/>
+ <keyword name="sigc::bind" link="group__bind.html#ga211b3361bb1ae7484b2b276fd926b962" type="function"/>
+ <keyword name="sigc::bind" link="group__bind.html#gaf1e076f0734addb8080f1cbcac602591" type="function"/>
+ <keyword name="sigc::bind" link="group__bind.html#ga047061c9fa7d9dcde68c27cceed476a1" type="function"/>
+ <keyword name="sigc::bind" link="group__bind.html#ga8366abceb86ee653ec2ac50cef9fd16d" type="function"/>
+ <keyword name="sigc::bind" link="group__bind.html#ga7f163c830d7906906cf21ff0c5e0f17f" type="function"/>
+ <keyword name="sigc::bind" link="group__bind.html#gac370f58b773f68c229c181f07e9b9e79" type="function"/>
+ <keyword name="sigc::bind" link="group__bind.html#ga962b581ef0c17562bb3317783d3ffe7d" type="function"/>
+ <keyword name="sigc::bind_return" link="group__bind.html#gaca1ae2466988d67d00a5f2cd16c8d90a" type="function"/>
+ <keyword name="sigc::compose" link="group__compose.html#ga34cf5da8f6323bfdc41bc7113d6ad20a" type="function"/>
+ <keyword name="sigc::compose" link="group__compose.html#ga4abf2a45eb2307a3dc5d870c86b0450d" type="function"/>
+ <keyword name="sigc::exception_catch" link="namespacesigc.html#a0ae3b8a1ba26920cee4d7d9df2c39ed9" type="function"/>
+ <keyword name="sigc::hide" link="group__hide.html#gaf2cefea3a99acd44f68121424103172d" type="function"/>
+ <keyword name="sigc::hide" link="group__hide.html#gacbbacd3553268d85b95e3a85aefb67e5" type="function"/>
+ <keyword name="sigc::hide_return" link="group__hide.html#gae4e6f5491471c12440f1c5d480726b98" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gaeef6e55681664df29b31edec51ea034d" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gaeef6e55681664df29b31edec51ea034d" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gaeef6e55681664df29b31edec51ea034d" type="function"/>
+ <keyword name="sigc::mem_fun" link="group__mem__fun.html#gaeef6e55681664df29b31edec51ea034d" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga7de39a04dfc6d37b2d12a25cdccfbe95" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga7de39a04dfc6d37b2d12a25cdccfbe95" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga7de39a04dfc6d37b2d12a25cdccfbe95" type="function"/>
+ <keyword name="sigc::mem_fun" link="group__mem__fun.html#ga7de39a04dfc6d37b2d12a25cdccfbe95" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gab1add5c927b51b935b4f2d40558079fa" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gab1add5c927b51b935b4f2d40558079fa" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gab1add5c927b51b935b4f2d40558079fa" type="function"/>
+ <keyword name="sigc::mem_fun" link="group__mem__fun.html#gab1add5c927b51b935b4f2d40558079fa" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga1f1aa3b60c0d2d8b2470bba0b2b36023" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga1f1aa3b60c0d2d8b2470bba0b2b36023" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga1f1aa3b60c0d2d8b2470bba0b2b36023" type="function"/>
+ <keyword name="sigc::mem_fun" link="group__mem__fun.html#ga1f1aa3b60c0d2d8b2470bba0b2b36023" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga481ef34d8423d26e8ff0a1916cd295d5" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga481ef34d8423d26e8ff0a1916cd295d5" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga481ef34d8423d26e8ff0a1916cd295d5" type="function"/>
+ <keyword name="sigc::mem_fun" link="group__mem__fun.html#ga481ef34d8423d26e8ff0a1916cd295d5" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga09fb13b1684ec7c092ffef695dbb261a" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga09fb13b1684ec7c092ffef695dbb261a" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga09fb13b1684ec7c092ffef695dbb261a" type="function"/>
+ <keyword name="sigc::mem_fun" link="group__mem__fun.html#ga09fb13b1684ec7c092ffef695dbb261a" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga0d9b992d69123a524b6c70c458ad0d40" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga0d9b992d69123a524b6c70c458ad0d40" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga0d9b992d69123a524b6c70c458ad0d40" type="function"/>
+ <keyword name="sigc::mem_fun" link="group__mem__fun.html#ga0d9b992d69123a524b6c70c458ad0d40" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga5dcdaf235baa50049e6088d246853037" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga5dcdaf235baa50049e6088d246853037" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga5dcdaf235baa50049e6088d246853037" type="function"/>
+ <keyword name="sigc::mem_fun" link="group__mem__fun.html#ga5dcdaf235baa50049e6088d246853037" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga7f57ec0156d33b4aa98e259d2e2062db" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga7f57ec0156d33b4aa98e259d2e2062db" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga7f57ec0156d33b4aa98e259d2e2062db" type="function"/>
+ <keyword name="sigc::mem_fun" link="group__mem__fun.html#ga7f57ec0156d33b4aa98e259d2e2062db" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga0df7af9f32990cc624c4bb60782b4f78" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga0df7af9f32990cc624c4bb60782b4f78" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga0df7af9f32990cc624c4bb60782b4f78" type="function"/>
+ <keyword name="sigc::mem_fun" link="group__mem__fun.html#ga0df7af9f32990cc624c4bb60782b4f78" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga118b2610268701be95cdc6fddb7bab3b" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga118b2610268701be95cdc6fddb7bab3b" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga118b2610268701be95cdc6fddb7bab3b" type="function"/>
+ <keyword name="sigc::mem_fun" link="group__mem__fun.html#ga118b2610268701be95cdc6fddb7bab3b" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gaeb6bd4518e0f0c524dba13a6cbb2e319" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gaeb6bd4518e0f0c524dba13a6cbb2e319" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gaeb6bd4518e0f0c524dba13a6cbb2e319" type="function"/>
+ <keyword name="sigc::mem_fun" link="group__mem__fun.html#gaeb6bd4518e0f0c524dba13a6cbb2e319" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga02c906c95895c58e39ee301bb1577994" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga02c906c95895c58e39ee301bb1577994" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga02c906c95895c58e39ee301bb1577994" type="function"/>
+ <keyword name="sigc::mem_fun" link="group__mem__fun.html#ga02c906c95895c58e39ee301bb1577994" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gab138ae1a340be983166b69872826b37d" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gab138ae1a340be983166b69872826b37d" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gab138ae1a340be983166b69872826b37d" type="function"/>
+ <keyword name="sigc::mem_fun" link="group__mem__fun.html#gab138ae1a340be983166b69872826b37d" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga3e3841c4844715d2f2d832ed506f028f" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga3e3841c4844715d2f2d832ed506f028f" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga3e3841c4844715d2f2d832ed506f028f" type="function"/>
+ <keyword name="sigc::mem_fun" link="group__mem__fun.html#ga3e3841c4844715d2f2d832ed506f028f" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gaea5a2ace2699b8d1ffe93585e335548d" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gaea5a2ace2699b8d1ffe93585e335548d" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gaea5a2ace2699b8d1ffe93585e335548d" type="function"/>
+ <keyword name="sigc::mem_fun" link="group__mem__fun.html#gaea5a2ace2699b8d1ffe93585e335548d" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gadf6b6d22c503b439019f0a2e77352419" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gadf6b6d22c503b439019f0a2e77352419" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gadf6b6d22c503b439019f0a2e77352419" type="function"/>
+ <keyword name="sigc::mem_fun" link="group__mem__fun.html#gadf6b6d22c503b439019f0a2e77352419" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gab661fef0f04e2e439912eee6989e9657" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gab661fef0f04e2e439912eee6989e9657" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gab661fef0f04e2e439912eee6989e9657" type="function"/>
+ <keyword name="sigc::mem_fun" link="group__mem__fun.html#gab661fef0f04e2e439912eee6989e9657" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5" type="function"/>
+ <keyword name="sigc::mem_fun" link="group__mem__fun.html#ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gaa3778234963fa65d4f638856d91109d1" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gaa3778234963fa65d4f638856d91109d1" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gaa3778234963fa65d4f638856d91109d1" type="function"/>
+ <keyword name="sigc::mem_fun" link="group__mem__fun.html#gaa3778234963fa65d4f638856d91109d1" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gadadd40aba6dadd0edbaac609dfae3938" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gadadd40aba6dadd0edbaac609dfae3938" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gadadd40aba6dadd0edbaac609dfae3938" type="function"/>
+ <keyword name="sigc::mem_fun" link="group__mem__fun.html#gadadd40aba6dadd0edbaac609dfae3938" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gaa01df6c622d59cfd2d0d8aa3c04c36d1" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gaa01df6c622d59cfd2d0d8aa3c04c36d1" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#gaa01df6c622d59cfd2d0d8aa3c04c36d1" type="function"/>
+ <keyword name="sigc::mem_fun" link="group__mem__fun.html#gaa01df6c622d59cfd2d0d8aa3c04c36d1" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga9030b647c35e06c68342fee34e8fd320" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga9030b647c35e06c68342fee34e8fd320" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga9030b647c35e06c68342fee34e8fd320" type="function"/>
+ <keyword name="sigc::mem_fun" link="group__mem__fun.html#ga9030b647c35e06c68342fee34e8fd320" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga54e4bf947e8c93c56931b8e8f7ed0d2e" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga54e4bf947e8c93c56931b8e8f7ed0d2e" type="function"/>
+ <keyword name="sigc::mem_fun" link="namespacesigc.html#ga54e4bf947e8c93c56931b8e8f7ed0d2e" type="function"/>
+ <keyword name="sigc::mem_fun" link="group__mem__fun.html#ga54e4bf947e8c93c56931b8e8f7ed0d2e" type="function"/>
+ <keyword name="sigc::mem_fun0" link="namespacesigc.html#gaf71277763f14050e2d270fcf3ea41dc9" type="function"/>
+ <keyword name="sigc::mem_fun0" link="namespacesigc.html#gaf71277763f14050e2d270fcf3ea41dc9" type="function"/>
+ <keyword name="sigc::mem_fun0" link="namespacesigc.html#gaf71277763f14050e2d270fcf3ea41dc9" type="function"/>
+ <keyword name="sigc::mem_fun0" link="group__mem__fun.html#gaf71277763f14050e2d270fcf3ea41dc9" type="function"/>
+ <keyword name="sigc::mem_fun0" link="namespacesigc.html#gae03d0b73b85e85d2ad8bc43b19b855e3" type="function"/>
+ <keyword name="sigc::mem_fun0" link="namespacesigc.html#gae03d0b73b85e85d2ad8bc43b19b855e3" type="function"/>
+ <keyword name="sigc::mem_fun0" link="namespacesigc.html#gae03d0b73b85e85d2ad8bc43b19b855e3" type="function"/>
+ <keyword name="sigc::mem_fun0" link="group__mem__fun.html#gae03d0b73b85e85d2ad8bc43b19b855e3" type="function"/>
+ <keyword name="sigc::mem_fun0" link="namespacesigc.html#ga765b35689a909fbc2a627be8256c5b1f" type="function"/>
+ <keyword name="sigc::mem_fun0" link="namespacesigc.html#ga765b35689a909fbc2a627be8256c5b1f" type="function"/>
+ <keyword name="sigc::mem_fun0" link="namespacesigc.html#ga765b35689a909fbc2a627be8256c5b1f" type="function"/>
+ <keyword name="sigc::mem_fun0" link="group__mem__fun.html#ga765b35689a909fbc2a627be8256c5b1f" type="function"/>
+ <keyword name="sigc::mem_fun1" link="namespacesigc.html#gaade596a4dacfd1429039525bb9f399d0" type="function"/>
+ <keyword name="sigc::mem_fun1" link="namespacesigc.html#gaade596a4dacfd1429039525bb9f399d0" type="function"/>
+ <keyword name="sigc::mem_fun1" link="namespacesigc.html#gaade596a4dacfd1429039525bb9f399d0" type="function"/>
+ <keyword name="sigc::mem_fun1" link="group__mem__fun.html#gaade596a4dacfd1429039525bb9f399d0" type="function"/>
+ <keyword name="sigc::mem_fun1" link="namespacesigc.html#ga3dd8d2ed97310dbf4fa394999f0be7b7" type="function"/>
+ <keyword name="sigc::mem_fun1" link="namespacesigc.html#ga3dd8d2ed97310dbf4fa394999f0be7b7" type="function"/>
+ <keyword name="sigc::mem_fun1" link="namespacesigc.html#ga3dd8d2ed97310dbf4fa394999f0be7b7" type="function"/>
+ <keyword name="sigc::mem_fun1" link="group__mem__fun.html#ga3dd8d2ed97310dbf4fa394999f0be7b7" type="function"/>
+ <keyword name="sigc::mem_fun1" link="namespacesigc.html#gae0bebf0d8a2d36d93746c23d9eea668d" type="function"/>
+ <keyword name="sigc::mem_fun1" link="namespacesigc.html#gae0bebf0d8a2d36d93746c23d9eea668d" type="function"/>
+ <keyword name="sigc::mem_fun1" link="namespacesigc.html#gae0bebf0d8a2d36d93746c23d9eea668d" type="function"/>
+ <keyword name="sigc::mem_fun1" link="group__mem__fun.html#gae0bebf0d8a2d36d93746c23d9eea668d" type="function"/>
+ <keyword name="sigc::mem_fun2" link="namespacesigc.html#gaee7652f1a0625df50af50e28b5e2423e" type="function"/>
+ <keyword name="sigc::mem_fun2" link="namespacesigc.html#gaee7652f1a0625df50af50e28b5e2423e" type="function"/>
+ <keyword name="sigc::mem_fun2" link="namespacesigc.html#gaee7652f1a0625df50af50e28b5e2423e" type="function"/>
+ <keyword name="sigc::mem_fun2" link="group__mem__fun.html#gaee7652f1a0625df50af50e28b5e2423e" type="function"/>
+ <keyword name="sigc::mem_fun2" link="namespacesigc.html#ga184da4166c8b5409dc4b98d7bc16dff8" type="function"/>
+ <keyword name="sigc::mem_fun2" link="namespacesigc.html#ga184da4166c8b5409dc4b98d7bc16dff8" type="function"/>
+ <keyword name="sigc::mem_fun2" link="namespacesigc.html#ga184da4166c8b5409dc4b98d7bc16dff8" type="function"/>
+ <keyword name="sigc::mem_fun2" link="group__mem__fun.html#ga184da4166c8b5409dc4b98d7bc16dff8" type="function"/>
+ <keyword name="sigc::mem_fun2" link="namespacesigc.html#gab76f41aeada332b353b6fe2e96008831" type="function"/>
+ <keyword name="sigc::mem_fun2" link="namespacesigc.html#gab76f41aeada332b353b6fe2e96008831" type="function"/>
+ <keyword name="sigc::mem_fun2" link="namespacesigc.html#gab76f41aeada332b353b6fe2e96008831" type="function"/>
+ <keyword name="sigc::mem_fun2" link="group__mem__fun.html#gab76f41aeada332b353b6fe2e96008831" type="function"/>
+ <keyword name="sigc::mem_fun3" link="namespacesigc.html#ga14e07df139b5cb6897e671c50fc33cde" type="function"/>
+ <keyword name="sigc::mem_fun3" link="namespacesigc.html#ga14e07df139b5cb6897e671c50fc33cde" type="function"/>
+ <keyword name="sigc::mem_fun3" link="namespacesigc.html#ga14e07df139b5cb6897e671c50fc33cde" type="function"/>
+ <keyword name="sigc::mem_fun3" link="group__mem__fun.html#ga14e07df139b5cb6897e671c50fc33cde" type="function"/>
+ <keyword name="sigc::mem_fun3" link="namespacesigc.html#ga4f2fdbf02e8cac9492326a4a8ffdd012" type="function"/>
+ <keyword name="sigc::mem_fun3" link="namespacesigc.html#ga4f2fdbf02e8cac9492326a4a8ffdd012" type="function"/>
+ <keyword name="sigc::mem_fun3" link="namespacesigc.html#ga4f2fdbf02e8cac9492326a4a8ffdd012" type="function"/>
+ <keyword name="sigc::mem_fun3" link="group__mem__fun.html#ga4f2fdbf02e8cac9492326a4a8ffdd012" type="function"/>
+ <keyword name="sigc::mem_fun3" link="namespacesigc.html#ga2379e0d689fe4a99c7c669fc29817457" type="function"/>
+ <keyword name="sigc::mem_fun3" link="namespacesigc.html#ga2379e0d689fe4a99c7c669fc29817457" type="function"/>
+ <keyword name="sigc::mem_fun3" link="namespacesigc.html#ga2379e0d689fe4a99c7c669fc29817457" type="function"/>
+ <keyword name="sigc::mem_fun3" link="group__mem__fun.html#ga2379e0d689fe4a99c7c669fc29817457" type="function"/>
+ <keyword name="sigc::mem_fun4" link="namespacesigc.html#ga86da5637e2735480d525ffa930e7e21a" type="function"/>
+ <keyword name="sigc::mem_fun4" link="namespacesigc.html#ga86da5637e2735480d525ffa930e7e21a" type="function"/>
+ <keyword name="sigc::mem_fun4" link="namespacesigc.html#ga86da5637e2735480d525ffa930e7e21a" type="function"/>
+ <keyword name="sigc::mem_fun4" link="group__mem__fun.html#ga86da5637e2735480d525ffa930e7e21a" type="function"/>
+ <keyword name="sigc::mem_fun4" link="namespacesigc.html#ga94a2525ef116e16598b81b853544a170" type="function"/>
+ <keyword name="sigc::mem_fun4" link="namespacesigc.html#ga94a2525ef116e16598b81b853544a170" type="function"/>
+ <keyword name="sigc::mem_fun4" link="namespacesigc.html#ga94a2525ef116e16598b81b853544a170" type="function"/>
+ <keyword name="sigc::mem_fun4" link="group__mem__fun.html#ga94a2525ef116e16598b81b853544a170" type="function"/>
+ <keyword name="sigc::mem_fun4" link="namespacesigc.html#ga1bedd04f76ad3e21f614912562e95d83" type="function"/>
+ <keyword name="sigc::mem_fun4" link="namespacesigc.html#ga1bedd04f76ad3e21f614912562e95d83" type="function"/>
+ <keyword name="sigc::mem_fun4" link="namespacesigc.html#ga1bedd04f76ad3e21f614912562e95d83" type="function"/>
+ <keyword name="sigc::mem_fun4" link="group__mem__fun.html#ga1bedd04f76ad3e21f614912562e95d83" type="function"/>
+ <keyword name="sigc::mem_fun5" link="namespacesigc.html#ga5c2ca9cef8c857935a59133a73ef61f2" type="function"/>
+ <keyword name="sigc::mem_fun5" link="namespacesigc.html#ga5c2ca9cef8c857935a59133a73ef61f2" type="function"/>
+ <keyword name="sigc::mem_fun5" link="namespacesigc.html#ga5c2ca9cef8c857935a59133a73ef61f2" type="function"/>
+ <keyword name="sigc::mem_fun5" link="group__mem__fun.html#ga5c2ca9cef8c857935a59133a73ef61f2" type="function"/>
+ <keyword name="sigc::mem_fun5" link="namespacesigc.html#gaf060fe3a2be4ff7c0f50aef54b4dc8bf" type="function"/>
+ <keyword name="sigc::mem_fun5" link="namespacesigc.html#gaf060fe3a2be4ff7c0f50aef54b4dc8bf" type="function"/>
+ <keyword name="sigc::mem_fun5" link="namespacesigc.html#gaf060fe3a2be4ff7c0f50aef54b4dc8bf" type="function"/>
+ <keyword name="sigc::mem_fun5" link="group__mem__fun.html#gaf060fe3a2be4ff7c0f50aef54b4dc8bf" type="function"/>
+ <keyword name="sigc::mem_fun5" link="namespacesigc.html#ga3ef4bb904a751d29e2b6803ef81f72fa" type="function"/>
+ <keyword name="sigc::mem_fun5" link="namespacesigc.html#ga3ef4bb904a751d29e2b6803ef81f72fa" type="function"/>
+ <keyword name="sigc::mem_fun5" link="namespacesigc.html#ga3ef4bb904a751d29e2b6803ef81f72fa" type="function"/>
+ <keyword name="sigc::mem_fun5" link="group__mem__fun.html#ga3ef4bb904a751d29e2b6803ef81f72fa" type="function"/>
+ <keyword name="sigc::mem_fun6" link="namespacesigc.html#ga947f4410e62a2996023177e490c882b7" type="function"/>
+ <keyword name="sigc::mem_fun6" link="namespacesigc.html#ga947f4410e62a2996023177e490c882b7" type="function"/>
+ <keyword name="sigc::mem_fun6" link="namespacesigc.html#ga947f4410e62a2996023177e490c882b7" type="function"/>
+ <keyword name="sigc::mem_fun6" link="group__mem__fun.html#ga947f4410e62a2996023177e490c882b7" type="function"/>
+ <keyword name="sigc::mem_fun6" link="namespacesigc.html#gac0a6242da9bf96642f25c1363dfef383" type="function"/>
+ <keyword name="sigc::mem_fun6" link="namespacesigc.html#gac0a6242da9bf96642f25c1363dfef383" type="function"/>
+ <keyword name="sigc::mem_fun6" link="namespacesigc.html#gac0a6242da9bf96642f25c1363dfef383" type="function"/>
+ <keyword name="sigc::mem_fun6" link="group__mem__fun.html#gac0a6242da9bf96642f25c1363dfef383" type="function"/>
+ <keyword name="sigc::mem_fun6" link="namespacesigc.html#ga34ace98fbbd18cb635795639d0f22678" type="function"/>
+ <keyword name="sigc::mem_fun6" link="namespacesigc.html#ga34ace98fbbd18cb635795639d0f22678" type="function"/>
+ <keyword name="sigc::mem_fun6" link="namespacesigc.html#ga34ace98fbbd18cb635795639d0f22678" type="function"/>
+ <keyword name="sigc::mem_fun6" link="group__mem__fun.html#ga34ace98fbbd18cb635795639d0f22678" type="function"/>
+ <keyword name="sigc::mem_fun7" link="namespacesigc.html#ga1f704e475da2aad1717e059c264c1436" type="function"/>
+ <keyword name="sigc::mem_fun7" link="namespacesigc.html#ga1f704e475da2aad1717e059c264c1436" type="function"/>
+ <keyword name="sigc::mem_fun7" link="namespacesigc.html#ga1f704e475da2aad1717e059c264c1436" type="function"/>
+ <keyword name="sigc::mem_fun7" link="group__mem__fun.html#ga1f704e475da2aad1717e059c264c1436" type="function"/>
+ <keyword name="sigc::mem_fun7" link="namespacesigc.html#ga9899534bc8eb78c227d895b396710091" type="function"/>
+ <keyword name="sigc::mem_fun7" link="namespacesigc.html#ga9899534bc8eb78c227d895b396710091" type="function"/>
+ <keyword name="sigc::mem_fun7" link="namespacesigc.html#ga9899534bc8eb78c227d895b396710091" type="function"/>
+ <keyword name="sigc::mem_fun7" link="group__mem__fun.html#ga9899534bc8eb78c227d895b396710091" type="function"/>
+ <keyword name="sigc::mem_fun7" link="namespacesigc.html#ga3d174b01bf94dbda3aea58c25c2b3322" type="function"/>
+ <keyword name="sigc::mem_fun7" link="namespacesigc.html#ga3d174b01bf94dbda3aea58c25c2b3322" type="function"/>
+ <keyword name="sigc::mem_fun7" link="namespacesigc.html#ga3d174b01bf94dbda3aea58c25c2b3322" type="function"/>
+ <keyword name="sigc::mem_fun7" link="group__mem__fun.html#ga3d174b01bf94dbda3aea58c25c2b3322" type="function"/>
+ <keyword name="sigc::ptr_fun" link="group__ptr__fun.html#ga9c80de72f656fb05e81fda622dddc863" type="function"/>
+ <keyword name="sigc::ptr_fun" link="group__ptr__fun.html#ga9b1c3b4ecb24056f5bd38fc6a87f9ad1" type="function"/>
+ <keyword name="sigc::ptr_fun" link="group__ptr__fun.html#ga9c0db14ab1a864b2bad70000325d94c8" type="function"/>
+ <keyword name="sigc::ptr_fun" link="group__ptr__fun.html#ga1cd2254135f3afcfc5ce34e73cf2f48b" type="function"/>
+ <keyword name="sigc::ptr_fun" link="group__ptr__fun.html#gaa23ae1abf223560bcac001b86d3cc484" type="function"/>
+ <keyword name="sigc::ptr_fun" link="group__ptr__fun.html#gafd3087df10b981325953c93e914d451e" type="function"/>
+ <keyword name="sigc::ptr_fun" link="group__ptr__fun.html#ga0f4d43c3aace56cc5ce0f38886b9ace6" type="function"/>
+ <keyword name="sigc::ptr_fun" link="group__ptr__fun.html#ga65221432dda1b020b73349627762da70" type="function"/>
+ <keyword name="sigc::ptr_fun0" link="group__ptr__fun.html#gaad8dffc194a4e4dfa0935ce49d43cd5c" type="function"/>
+ <keyword name="sigc::ptr_fun1" link="group__ptr__fun.html#ga9b1b8e8f5555d6be4ba41be3fb82c94e" type="function"/>
+ <keyword name="sigc::ptr_fun2" link="group__ptr__fun.html#ga0244165b83e41a30b2dfb9523afad446" type="function"/>
+ <keyword name="sigc::ptr_fun3" link="group__ptr__fun.html#ga749e83ea85926d5ad6994d775f98de8d" type="function"/>
+ <keyword name="sigc::ptr_fun4" link="group__ptr__fun.html#gac6fa01189c786e778d943a2ee60896a4" type="function"/>
+ <keyword name="sigc::ptr_fun5" link="group__ptr__fun.html#ga37ae059caefef68e441d3dd7d5b11cce" type="function"/>
+ <keyword name="sigc::ptr_fun6" link="group__ptr__fun.html#ga8cdf17b7ec15b260f5147e1171dd5299" type="function"/>
+ <keyword name="sigc::ptr_fun7" link="group__ptr__fun.html#ga82e53ab558dae814c16a09edb53617bb" type="function"/>
+ <keyword name="sigc::ref" link="namespacesigc.html#a670882bd3fa5890b464871ac515aaba9" type="function"/>
+ <keyword name="sigc::ref" link="namespacesigc.html#a48e982c74c057b5630246ba436524041" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga31061f134d93297fd0b4f2d56efafbe3" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga63ead6c4883a6553446594e6027dc96c" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga415bd3f44f1785ce30452a4ca8e46dd0" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga6f86026b9959cdd62287b29407c71e97" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga8fbc58cc94f7f4a46c1557091974a278" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga1d0d963fa703a6f85b8002c3a405c00a" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga39ba6af86d75de1535e4fa8af1e6081b" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga02a44f2ea2386f8e4fa41cb582c2008d" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#gade9ed42b368ea6eee6d42c8116cd28dd" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#gaab22de279058fd53d5ef720ad3932b56" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga42f7c6ae10273b6577909f89bd76dc1f" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga1b2477c6ed3347fae35c66f25977f9dc" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#gad73b9445fab1544d7550db964426520d" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#gacbb4a1e1c3447205bf507d6912847015" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#gace1ef4f9ca35373adaad3c29db2b918f" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga1ec0f19b59050f8f01c8969835b3c742" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#gaebe9c150af92e230257bbbdb728e5a07" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga971017d74a880ee10555ebd32483d188" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#gaddf62506fc01f1cdfcadef27e47f9b59" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#gad916eb17d984df3b7da9b7d3d041168a" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga8362fa71a99b71b843205e0482b281fc" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga9c139b3254f5020de44a73c7dd795819" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga12e152b4340f83bd1f6cec92771fa82a" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#gadda8029b543d9b657f01e6ba9a9ef8fd" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#gadc01bb77132048902ec8965d012edcd3" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga45b921820c277072b6f7e856ddbcfca1" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#gaf420d79b4077b848ef1aef4b68810d6e" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga899ae79da0e918ad9fc8f2c8e8066218" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga8540037bfd4da57495b60dd9487c6d0b" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga31ace8220cbb70b8e7f545ee4c1b6610" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga9f45f05c95abc9d20ae9d39589f5d72e" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga17e8761db2fafa2d3a92d19d8ce47511" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga0688ca8eb3ee82e191563ba7f81366b2" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#gae035134414ed79a187a6b41a115a3759" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga8e9ee582f601451f3aa7c3d37d03b952" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga81e06b857f7a44b0589125e28535f87f" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga411bdd3476f80d627c50d47149862ec2" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga995053759ee8ee89663f9625a4aaf596" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga851188153c54bb1eb8fee425f9796981" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#gaa951debcabd066f8c3479617aaa9689e" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga312fca59eb8b4ca0e078b1cf7f407212" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga84f4247ab4cc559aed835ccd943fab70" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga271911579dfbac317a53f62f0773e420" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga97b4f14b5a7991eba60b635871d6a7f9" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga4e9179cc61db0069db209bc7632b3dee" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga637af7b3e60f5657dcd62e350ec76675" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga17ceafe96cdf3bd37ccd401f413f8748" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga75578233ce4f47c5f610569a5ffe84cc" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#gabb08dd87f3ec392536b656b6b3e959a0" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga5a2600190453d4eb11c14f99973044bc" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga7df338186f09b1c89c2840f6744362e9" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#gae2d9d2e91b2f8d256e4ad8da1c3c59e0" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga70e615639e07e90a997a378cf877b106" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#gad225dee1d71c68d0ee71f3f0fedcfc1b" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga9c08fe50076854f15c923ab4183aed0f" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga3fbd72b71a4ea4fafa487b5932acd797" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga23978c94d9d3c934803898c3bf48ff7d" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga75cc92c15faf06d5293ff34179f21899" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga0d67e207b3d753ab71b3801981cfeff3" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#gaa5dfa926e3bfc7b82e0d14e4d9c9ff32" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#gade02a3d76cf35465acfa39d4e03a40d5" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga45fa726d6497c6b0994444fd2569581c" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga24e30de09c3784220829f52bb068b8c0" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga09db0b458651a7fcd985e5dd4e50caa0" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga8b98eeb2a61b5b1f84dcd1d20fe666f1" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga53d620659c82cbb84da3812ac874f4b7" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga6d7f05b930056183bc7537447c80e59b" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga5b65e9a9794300c40b1577302e006fbd" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga55236721b80a72f40453d1b939316635" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga05d2c3c043bed420ba8ba6f40f42f692" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga42be2d2fbf03fbaba1ad7d8cbbb8bce4" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga255fac4b456d69d033b327b1d533f054" type="function"/>
+ <keyword name="sigc::retype" link="group__retype.html#ga37a057f88e6ffbb8d4172d6446116796" type="function"/>
+ <keyword name="sigc::retype_return" link="group__retype.html#ga23a8cdbc12c57fbef0866b5c51d71588" type="function"/>
+ <keyword name="sigc::track_obj" link="group__track__obj.html#ga8fd1ab36d123ff83dd4cd8dc58bb28e2" type="function"/>
+ <keyword name="sigc::track_obj" link="group__track__obj.html#ga60842510c2387ec49c43149d94fb1b72" type="function"/>
+ <keyword name="sigc::track_obj" link="group__track__obj.html#ga52b11304cb05441237a8dcc651cb724e" type="function"/>
+ <keyword name="sigc::track_obj" link="group__track__obj.html#gaea44f2388c18ca8508818ff6b7756216" type="function"/>
+ <keyword name="sigc::track_obj" link="group__track__obj.html#ga337dc48ba1e394f572d5d914b83f57a0" type="function"/>
+ <keyword name="sigc::track_obj" link="group__track__obj.html#ga0304ca1269ed352fcc1c81324062302e" type="function"/>
+ <keyword name="sigc::track_obj" link="group__track__obj.html#ga5ea3e9f52643d7ab1bcfa4f419e7d38f" type="function"/>
+ <keyword name="sigc::unwrap" link="namespacesigc.html#a2f758c77e8743093f938d0c5dbf06778" type="function"/>
+ <keyword name="sigc::unwrap" link="namespacesigc.html#a3b5529822bdaf60f07456633e0f40282" type="function"/>
+ <keyword name="sigc::unwrap" link="namespacesigc.html#a3256789f3d3bb134471d7cf8fcf4d91a" type="function"/>
+ <keyword name="sigc::visit_each" link="group__sigcfunctors.html#ga64cb7832acc1e58efb5ffe0b4f5e9404" type="function"/>
+ <keyword name="sigc::visit_each_type" link="group__sigcfunctors.html#gada222d975b87d64cfa7a7f29244ae587" type="function"/>
+ </functions>
+</book>
--- /dev/null
+<?xml version='1.0' encoding='UTF-8' standalone='yes' ?>
+<tagfile doxygen_version="1.9.1">
+ <compound kind="class">
+ <name>adapts< T_setter ></name>
+ <filename>structsigc_1_1adapts.html</filename>
+ <base>sigc::adaptor_base</base>
+ <member kind="typedef">
+ <type>adaptor_trait< T_setter >::adaptor_type</type>
+ <name>adaptor_type</name>
+ <anchorfile>structsigc_1_1adapts.html</anchorfile>
+ <anchor>a5c3f3b614455552f4cd5d88b1f330248</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>adaptor_trait< T_setter >::result_type</type>
+ <name>result_type</name>
+ <anchorfile>structsigc_1_1adapts.html</anchorfile>
+ <anchor>a914e75556dae1fdcf0162c4c99aca79d</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>adapts</name>
+ <anchorfile>structsigc_1_1adapts.html</anchorfile>
+ <anchor>a947b69ccbdcabd4ef4163dcab96096f8</anchor>
+ <arglist>(const T_setter &_A_functor)</arglist>
+ </member>
+ <member kind="variable">
+ <type>adaptor_type</type>
+ <name>functor_</name>
+ <anchorfile>structsigc_1_1adapts.html</anchorfile>
+ <anchor>a2f4b37eb160708baf17de57f2abce7a7</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>bound_argument< T_bound ></name>
+ <filename>classsigc_1_1bound__argument.html</filename>
+ <member kind="function">
+ <type></type>
+ <name>bound_argument</name>
+ <anchorfile>classsigc_1_1bound__argument.html</anchorfile>
+ <anchor>a495bb69a41b38eda5d6ace5a36807a37</anchor>
+ <arglist>(const T_bound &_A_argument)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_bound &</type>
+ <name>invoke</name>
+ <anchorfile>classsigc_1_1bound__argument.html</anchorfile>
+ <anchor>af1cf20526bade89328a1ed398055bbba</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const T_bound &</type>
+ <name>visit</name>
+ <anchorfile>classsigc_1_1bound__argument.html</anchorfile>
+ <anchor>ab29e53c5e983c45e4963e0ecace26465</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>bound_argument< T_return ></name>
+ <filename>classsigc_1_1bound__argument.html</filename>
+ <member kind="function">
+ <type></type>
+ <name>bound_argument</name>
+ <anchorfile>classsigc_1_1bound__argument.html</anchorfile>
+ <anchor>a495bb69a41b38eda5d6ace5a36807a37</anchor>
+ <arglist>(const T_return &_A_argument)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return &</type>
+ <name>invoke</name>
+ <anchorfile>classsigc_1_1bound__argument.html</anchorfile>
+ <anchor>af1cf20526bade89328a1ed398055bbba</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const T_return &</type>
+ <name>visit</name>
+ <anchorfile>classsigc_1_1bound__argument.html</anchorfile>
+ <anchor>ab29e53c5e983c45e4963e0ecace26465</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>bound_argument< T_type1 ></name>
+ <filename>classsigc_1_1bound__argument.html</filename>
+ <member kind="function">
+ <type></type>
+ <name>bound_argument</name>
+ <anchorfile>classsigc_1_1bound__argument.html</anchorfile>
+ <anchor>a495bb69a41b38eda5d6ace5a36807a37</anchor>
+ <arglist>(const T_type1 &_A_argument)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_type1 &</type>
+ <name>invoke</name>
+ <anchorfile>classsigc_1_1bound__argument.html</anchorfile>
+ <anchor>af1cf20526bade89328a1ed398055bbba</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const T_type1 &</type>
+ <name>visit</name>
+ <anchorfile>classsigc_1_1bound__argument.html</anchorfile>
+ <anchor>ab29e53c5e983c45e4963e0ecace26465</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>const_limit_reference< T_obj ></name>
+ <filename>classsigc_1_1const__limit__reference.html</filename>
+ <member kind="function">
+ <type></type>
+ <name>const_limit_reference</name>
+ <anchorfile>classsigc_1_1const__limit__reference.html</anchorfile>
+ <anchor>acee8a4c09720730cd5f66696fd018b4c</anchor>
+ <arglist>(const T_obj &_A_target)</arglist>
+ </member>
+ <member kind="function">
+ <type>const T_obj &</type>
+ <name>invoke</name>
+ <anchorfile>classsigc_1_1const__limit__reference.html</anchorfile>
+ <anchor>abb05a4234000dbf4a256b446d3ef580d</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>const T_obj &</type>
+ <name>visit</name>
+ <anchorfile>classsigc_1_1const__limit__reference.html</anchorfile>
+ <anchor>aa7486303566b2a9a74e55561083ed3d9</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>const_limit_reference< T_wrapped ></name>
+ <filename>classsigc_1_1const__limit__reference.html</filename>
+ <member kind="function">
+ <type></type>
+ <name>const_limit_reference</name>
+ <anchorfile>classsigc_1_1const__limit__reference.html</anchorfile>
+ <anchor>acee8a4c09720730cd5f66696fd018b4c</anchor>
+ <arglist>(const T_wrapped &_A_target)</arglist>
+ </member>
+ <member kind="function">
+ <type>const T_wrapped &</type>
+ <name>invoke</name>
+ <anchorfile>classsigc_1_1const__limit__reference.html</anchorfile>
+ <anchor>abb05a4234000dbf4a256b446d3ef580d</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>const T_wrapped &</type>
+ <name>visit</name>
+ <anchorfile>classsigc_1_1const__limit__reference.html</anchorfile>
+ <anchor>aa7486303566b2a9a74e55561083ed3d9</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>const_volatile_limit_reference< T_obj ></name>
+ <filename>classsigc_1_1const__volatile__limit__reference.html</filename>
+ <member kind="function">
+ <type></type>
+ <name>const_volatile_limit_reference</name>
+ <anchorfile>classsigc_1_1const__volatile__limit__reference.html</anchorfile>
+ <anchor>a9a01809bae79cb1b13ee50ce9d84dcb8</anchor>
+ <arglist>(const T_obj &_A_target)</arglist>
+ </member>
+ <member kind="function">
+ <type>const volatile T_obj &</type>
+ <name>invoke</name>
+ <anchorfile>classsigc_1_1const__volatile__limit__reference.html</anchorfile>
+ <anchor>ac09d022e8991a946d49a714df8b2f1c7</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>const T_obj &</type>
+ <name>visit</name>
+ <anchorfile>classsigc_1_1const__volatile__limit__reference.html</anchorfile>
+ <anchor>a41c17ef86e8c65998ba42097c7ad5f09</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>limit_reference< T_obj ></name>
+ <filename>classsigc_1_1limit__reference.html</filename>
+ <member kind="function">
+ <type></type>
+ <name>limit_reference</name>
+ <anchorfile>classsigc_1_1limit__reference.html</anchorfile>
+ <anchor>a58bf17e1eaa63d86336c831fa885bc66</anchor>
+ <arglist>(T_obj &_A_target)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_obj &</type>
+ <name>invoke</name>
+ <anchorfile>classsigc_1_1limit__reference.html</anchorfile>
+ <anchor>affd2902cd78ccdae45c499058c83e992</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>const T_obj &</type>
+ <name>visit</name>
+ <anchorfile>classsigc_1_1limit__reference.html</anchorfile>
+ <anchor>affeb3929fdc606c8fb7f8f29fa6fd12d</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>limit_reference< T_wrapped ></name>
+ <filename>classsigc_1_1limit__reference.html</filename>
+ <member kind="function">
+ <type></type>
+ <name>limit_reference</name>
+ <anchorfile>classsigc_1_1limit__reference.html</anchorfile>
+ <anchor>a58bf17e1eaa63d86336c831fa885bc66</anchor>
+ <arglist>(T_wrapped &_A_target)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_wrapped &</type>
+ <name>invoke</name>
+ <anchorfile>classsigc_1_1limit__reference.html</anchorfile>
+ <anchor>affd2902cd78ccdae45c499058c83e992</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>const T_wrapped &</type>
+ <name>visit</name>
+ <anchorfile>classsigc_1_1limit__reference.html</anchorfile>
+ <anchor>affeb3929fdc606c8fb7f8f29fa6fd12d</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::adaptor_base</name>
+ <filename>structsigc_1_1adaptor__base.html</filename>
+ <base>sigc::functor_base</base>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::adaptor_functor</name>
+ <filename>structsigc_1_1adaptor__functor.html</filename>
+ <templarg></templarg>
+ <base>sigc::adaptor_base</base>
+ <member kind="typedef">
+ <type>functor_trait< T_functor >::result_type</type>
+ <name>result_type</name>
+ <anchorfile>structsigc_1_1adaptor__functor.html</anchorfile>
+ <anchor>adc1e7ebba9db294494c62666e10b719b</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>adaptor_functor</name>
+ <anchorfile>structsigc_1_1adaptor__functor.html</anchorfile>
+ <anchor>a39ef4610f8e0f03425b6f4a44b59e5fb</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>adaptor_functor</name>
+ <anchorfile>structsigc_1_1adaptor__functor.html</anchorfile>
+ <anchor>ac5907212f7ee2eadf10b31757a0c5930</anchor>
+ <arglist>(const T_functor &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>adaptor_functor</name>
+ <anchorfile>structsigc_1_1adaptor__functor.html</anchorfile>
+ <anchor>af765e401002eb15f18aca5cfaa678b01</anchor>
+ <arglist>(const T_type &_A_type)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1adaptor__functor.html</anchorfile>
+ <anchor>aa8f3859324cce86596f0eb81b7bb6037</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1adaptor__functor.html</anchorfile>
+ <anchor>ad5f69b862958bf7c45e7f6d3bc5f4c6e</anchor>
+ <arglist>(T_arg1 _A_arg1) const</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1adaptor__functor.html</anchorfile>
+ <anchor>aab920cf1b05ce5d6c9513aa18323ea2a</anchor>
+ <arglist>(T_arg1 _A_arg1, T_arg2 _A_arg2) const</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1adaptor__functor.html</anchorfile>
+ <anchor>a0da9456dab8a22caffe6cfd624e32e30</anchor>
+ <arglist>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3) const</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1adaptor__functor.html</anchorfile>
+ <anchor>a2b393cd9388414a1a6ad7148eec4354a</anchor>
+ <arglist>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4) const</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1adaptor__functor.html</anchorfile>
+ <anchor>a9bec9cfe2f00505a35cdb2b8d5117b09</anchor>
+ <arglist>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5) const</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1adaptor__functor.html</anchorfile>
+ <anchor>a824de5f3164f45f78ea3771743b94ca4</anchor>
+ <arglist>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6) const</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1adaptor__functor.html</anchorfile>
+ <anchor>a5be4edc8ea900c6454cb024836b9f655</anchor>
+ <arglist>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6, T_arg7 _A_arg7) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>T_functor</type>
+ <name>functor_</name>
+ <anchorfile>structsigc_1_1adaptor__functor.html</anchorfile>
+ <anchor>a4faff6b7a82f4f6d92e3d3b0aa8fdca8</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::adaptor_trait</name>
+ <filename>structsigc_1_1adaptor__trait.html</filename>
+ <templarg></templarg>
+ <templarg>I_isadaptor</templarg>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::adaptor_trait< T_functor, false ></name>
+ <filename>structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html</filename>
+ <templarg></templarg>
+ <member kind="typedef">
+ <type>adaptor_functor< functor_type ></type>
+ <name>adaptor_type</name>
+ <anchorfile>structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html</anchorfile>
+ <anchor>ad3bd68364a24b2b6580b523d5301b25c</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>functor_trait< T_functor >::functor_type</type>
+ <name>functor_type</name>
+ <anchorfile>structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html</anchorfile>
+ <anchor>acb1a7066d665d00e2525c49d089efc0f</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>functor_trait< T_functor >::result_type</type>
+ <name>result_type</name>
+ <anchorfile>structsigc_1_1adaptor__trait_3_01T__functor_00_01false_01_4.html</anchorfile>
+ <anchor>a512a6d201bdd43574a2df993b3b85d0e</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::adaptor_trait< T_functor, true ></name>
+ <filename>structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html</filename>
+ <templarg></templarg>
+ <member kind="typedef">
+ <type>T_functor</type>
+ <name>adaptor_type</name>
+ <anchorfile>structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html</anchorfile>
+ <anchor>a449daad4cd77bd1fbfe59d8fae9d9039</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_functor</type>
+ <name>functor_type</name>
+ <anchorfile>structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html</anchorfile>
+ <anchor>ae065e339af2abe58cad43d630328240f</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_functor::result_type</type>
+ <name>result_type</name>
+ <anchorfile>structsigc_1_1adaptor__trait_3_01T__functor_00_01true_01_4.html</anchorfile>
+ <anchor>a6b83ed91f53a25e7002546a2835457b3</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::adapts</name>
+ <filename>structsigc_1_1adapts.html</filename>
+ <templarg></templarg>
+ <base>sigc::adaptor_base</base>
+ <member kind="typedef">
+ <type>adaptor_trait< T_functor >::adaptor_type</type>
+ <name>adaptor_type</name>
+ <anchorfile>structsigc_1_1adapts.html</anchorfile>
+ <anchor>a5c3f3b614455552f4cd5d88b1f330248</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>adaptor_trait< T_functor >::result_type</type>
+ <name>result_type</name>
+ <anchorfile>structsigc_1_1adapts.html</anchorfile>
+ <anchor>a914e75556dae1fdcf0162c4c99aca79d</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>adapts</name>
+ <anchorfile>structsigc_1_1adapts.html</anchorfile>
+ <anchor>a947b69ccbdcabd4ef4163dcab96096f8</anchor>
+ <arglist>(const T_functor &_A_functor)</arglist>
+ </member>
+ <member kind="variable">
+ <type>adaptor_type</type>
+ <name>functor_</name>
+ <anchorfile>structsigc_1_1adapts.html</anchorfile>
+ <anchor>a2f4b37eb160708baf17de57f2abce7a7</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::bind_functor</name>
+ <filename>structsigc_1_1bind__functor.html</filename>
+ <templarg>I_location</templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></name>
+ <filename>structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::adapts</base>
+ <member kind="typedef">
+ <type>adapts< T_functor >::adaptor_type</type>
+ <name>adaptor_type</name>
+ <anchorfile>structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>ac6004db92703257f83addd412037f1f7</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>adaptor_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a1c6d091ffd70c23930cf6e2b9042d466</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bind_functor</name>
+ <anchorfile>structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>ac170bca0fe2af4722cf6e1fd6b3de128</anchor>
+ <arglist>(type_trait_take_t< T_functor > _A_func, type_trait_take_t< T_bound > _A_bound)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a0f1c2891d52c9f564e571209dbef6f54</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>adf9d663d20ff816a2a4c7d8ffb567eb3</anchor>
+ <arglist>(T_arg1 _A_arg1)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a2f2685399ae595b5e51a3af8c2610481</anchor>
+ <arglist>(T_arg1 _A_arg1, T_arg2 _A_arg2)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a711b443e433977b183c789b175865a1e</anchor>
+ <arglist>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a1d0808644eb398cf7036a446b853220d</anchor>
+ <arglist>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a8fb31d32467dfe99815ca39b766cafac</anchor>
+ <arglist>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a40d96a28bc0a1b7d11e267cc1d7bc517</anchor>
+ <arglist>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)</arglist>
+ </member>
+ <member kind="variable">
+ <type>bound_argument< T_bound ></type>
+ <name>bound_</name>
+ <anchorfile>structsigc_1_1bind__functor_3_010_00_01T__functor_00_01T__bound_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>afbbf5b4d89cf98a1224da5d72554afdc</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></name>
+ <filename>structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::adapts</base>
+ <member kind="typedef">
+ <type>adapts< T_functor >::adaptor_type</type>
+ <name>adaptor_type</name>
+ <anchorfile>structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>ac249b81b5d6fff6e7c4b1d9b47a98077</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>adaptor_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>abd1e51093bf7d4428e443c2e6704bed9</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bind_functor</name>
+ <anchorfile>structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>ad61bb64a42d144999a94767cd6031259</anchor>
+ <arglist>(type_trait_take_t< T_functor > _A_func, type_trait_take_t< T_type1 > _A_bound1)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a5bd5dd13ef2cd495cfd23b8d0f7cffbd</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a92e97561144280879cce1d04aa8fefa0</anchor>
+ <arglist>(T_arg1 _A_arg1)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a3bdae6371687d34e14925b732361f13f</anchor>
+ <arglist>(T_arg1 _A_arg1, T_arg2 _A_arg2)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a768079067de0ad3fa076eef0bfa5da88</anchor>
+ <arglist>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a2f959146fe7ce94745de2b1d10f48a2e</anchor>
+ <arglist>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a636774490286342a00251061eb5c550d</anchor>
+ <arglist>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a2774a9d3a219ad25326a6490aa4038ae</anchor>
+ <arglist>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)</arglist>
+ </member>
+ <member kind="variable">
+ <type>bound_argument< T_type1 ></type>
+ <name>bound1_</name>
+ <anchorfile>structsigc_1_1bind__functor_3-1_00_01T__functor_00_01T__type1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a5e92e05deb3d9e952a49a338bac42cb4</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::bind_return_functor</name>
+ <filename>structsigc_1_1bind__return__functor.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::adapts</base>
+ <member kind="typedef">
+ <type>unwrap_reference< T_return >::type</type>
+ <name>result_type</name>
+ <anchorfile>structsigc_1_1bind__return__functor.html</anchorfile>
+ <anchor>a4fe6cb8d80573ae7abe934ba54879592</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bind_return_functor</name>
+ <anchorfile>structsigc_1_1bind__return__functor.html</anchorfile>
+ <anchor>a1fa9551283794b249cbbdf7d270745d4</anchor>
+ <arglist>(type_trait_take_t< T_functor > _A_functor, type_trait_take_t< T_return > _A_ret_value)</arglist>
+ </member>
+ <member kind="function">
+ <type>unwrap_reference< T_return >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1bind__return__functor.html</anchorfile>
+ <anchor>a35959a6f4d5f6ddc83f603ee67d25981</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>unwrap_reference< T_return >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1bind__return__functor.html</anchorfile>
+ <anchor>aea28cfb0443ae04982fc47c9955303fe</anchor>
+ <arglist>(T_arg1 _A_a1)</arglist>
+ </member>
+ <member kind="function">
+ <type>unwrap_reference< T_return >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1bind__return__functor.html</anchorfile>
+ <anchor>a0794dd9e28353fd8b9a7454b2621343e</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2)</arglist>
+ </member>
+ <member kind="function">
+ <type>unwrap_reference< T_return >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1bind__return__functor.html</anchorfile>
+ <anchor>aa1fddb53a22007f28b4a79949ecd5d4c</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)</arglist>
+ </member>
+ <member kind="function">
+ <type>unwrap_reference< T_return >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1bind__return__functor.html</anchorfile>
+ <anchor>a82f9312afce202883c1f6431b3b6d1c6</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)</arglist>
+ </member>
+ <member kind="function">
+ <type>unwrap_reference< T_return >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1bind__return__functor.html</anchorfile>
+ <anchor>a87958210a6c240fd56e7386184b8da00</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)</arglist>
+ </member>
+ <member kind="function">
+ <type>unwrap_reference< T_return >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1bind__return__functor.html</anchorfile>
+ <anchor>a58f654259665ed6f02df042c5b00f888</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)</arglist>
+ </member>
+ <member kind="function">
+ <type>unwrap_reference< T_return >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1bind__return__functor.html</anchorfile>
+ <anchor>a1b9d2dc672b8dfd7c769bbcedf25d8aa</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)</arglist>
+ </member>
+ <member kind="variable">
+ <type>bound_argument< T_return ></type>
+ <name>ret_value_</name>
+ <anchorfile>structsigc_1_1bind__return__functor.html</anchorfile>
+ <anchor>aa7b8287c19d98cec75a7e64a9464772e</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_argument</name>
+ <filename>classsigc_1_1bound__argument.html</filename>
+ <templarg></templarg>
+ <member kind="function">
+ <type></type>
+ <name>bound_argument</name>
+ <anchorfile>classsigc_1_1bound__argument.html</anchorfile>
+ <anchor>a495bb69a41b38eda5d6ace5a36807a37</anchor>
+ <arglist>(const T_type &_A_argument)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_type &</type>
+ <name>invoke</name>
+ <anchorfile>classsigc_1_1bound__argument.html</anchorfile>
+ <anchor>af1cf20526bade89328a1ed398055bbba</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const T_type &</type>
+ <name>visit</name>
+ <anchorfile>classsigc_1_1bound__argument.html</anchorfile>
+ <anchor>ab29e53c5e983c45e4963e0ecace26465</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_argument< const_reference_wrapper< T_wrapped > ></name>
+ <filename>classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html</filename>
+ <templarg></templarg>
+ <member kind="function">
+ <type></type>
+ <name>bound_argument</name>
+ <anchorfile>classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html</anchorfile>
+ <anchor>afdfab4386d34bd03e82b05a2eb1f2afe</anchor>
+ <arglist>(const const_reference_wrapper< T_wrapped > &_A_argument)</arglist>
+ </member>
+ <member kind="function">
+ <type>const T_wrapped &</type>
+ <name>invoke</name>
+ <anchorfile>classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html</anchorfile>
+ <anchor>aa08b2efa73ad0a928f0be217da940671</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const const_limit_reference< T_wrapped > &</type>
+ <name>visit</name>
+ <anchorfile>classsigc_1_1bound__argument_3_01const__reference__wrapper_3_01T__wrapped_01_4_01_4.html</anchorfile>
+ <anchor>a11b6cda42100c2c463e50942c41ff9eb</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_argument< reference_wrapper< T_wrapped > ></name>
+ <filename>classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html</filename>
+ <templarg></templarg>
+ <member kind="function">
+ <type></type>
+ <name>bound_argument</name>
+ <anchorfile>classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html</anchorfile>
+ <anchor>a46f705d774a2436055785b7a55830349</anchor>
+ <arglist>(const reference_wrapper< T_wrapped > &_A_argument)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_wrapped &</type>
+ <name>invoke</name>
+ <anchorfile>classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html</anchorfile>
+ <anchor>adbeb73917559e0764bf367dfc6c4141d</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const limit_reference< T_wrapped > &</type>
+ <name>visit</name>
+ <anchorfile>classsigc_1_1bound__argument_3_01reference__wrapper_3_01T__wrapped_01_4_01_4.html</anchorfile>
+ <anchor>a5123890110dc1013071e68a615692ce3</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_argument< std::reference_wrapper< T_wrapped > ></name>
+ <filename>classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html</filename>
+ <templarg></templarg>
+ <member kind="function">
+ <type></type>
+ <name>bound_argument</name>
+ <anchorfile>classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html</anchorfile>
+ <anchor>a597709183c9a0b753f4674aaab80b4ff</anchor>
+ <arglist>(const std::reference_wrapper< T_wrapped > &_A_argument)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_wrapped &</type>
+ <name>invoke</name>
+ <anchorfile>classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html</anchorfile>
+ <anchor>a38950827998907494c25397f01552730</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const limit_reference< T_wrapped > &</type>
+ <name>visit</name>
+ <anchorfile>classsigc_1_1bound__argument_3_01std_1_1reference__wrapper_3_01T__wrapped_01_4_01_4.html</anchorfile>
+ <anchor>a3d34b13540ac33e677024727ffd3a36e</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_const_mem_functor0</name>
+ <filename>classsigc_1_1bound__const__mem__functor0.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::const_mem_functor0</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor0.html</anchorfile>
+ <anchor>a12ae83ad7820bd716ed8a07484a339d9</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_mem_functor0</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor0.html</anchorfile>
+ <anchor>a44aeae8d1432f66fce9cd385094b78fa</anchor>
+ <arglist>(const T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_mem_functor0</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor0.html</anchorfile>
+ <anchor>a67756fc7a32eb42309a1d55aea2eeb19</anchor>
+ <arglist>(const T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor0.html</anchorfile>
+ <anchor>a7949abb2e0a675ab7faccf4b0c2b5480</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="variable">
+ <type>const_limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor0.html</anchorfile>
+ <anchor>afe36947825350dc17d7fed286f57c32a</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_const_mem_functor1</name>
+ <filename>classsigc_1_1bound__const__mem__functor1.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::const_mem_functor1</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor1.html</anchorfile>
+ <anchor>a65f0cde178bdd7a26fe687a8748dac4e</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_mem_functor1</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor1.html</anchorfile>
+ <anchor>af62c239e5612df1b7c4c91a52a2e0c62</anchor>
+ <arglist>(const T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_mem_functor1</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor1.html</anchorfile>
+ <anchor>aca80f40c27a3346521ffee81ba79da77</anchor>
+ <arglist>(const T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor1.html</anchorfile>
+ <anchor>a4ba51a05a053caf20d9306efb0f05791</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>const_limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor1.html</anchorfile>
+ <anchor>ac4141561bf43206a396d082dd0089fb2</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_const_mem_functor2</name>
+ <filename>classsigc_1_1bound__const__mem__functor2.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::const_mem_functor2</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor2.html</anchorfile>
+ <anchor>abe2916ee9b6867554b48370000eb6886</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_mem_functor2</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor2.html</anchorfile>
+ <anchor>ab5213783f248b53b357ea6385b7bbe7a</anchor>
+ <arglist>(const T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_mem_functor2</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor2.html</anchorfile>
+ <anchor>a6732b8f5b308ff8ff1adea9e3734f4bf</anchor>
+ <arglist>(const T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor2.html</anchorfile>
+ <anchor>a00df32df2a5bafc0adb39da243ad3a3d</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>const_limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor2.html</anchorfile>
+ <anchor>a3994b65f2ec0b45f5b502f07bf7baca1</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_const_mem_functor3</name>
+ <filename>classsigc_1_1bound__const__mem__functor3.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::const_mem_functor3</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor3.html</anchorfile>
+ <anchor>ab4e793d8c65bf8754aea133a2473dc6c</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_mem_functor3</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor3.html</anchorfile>
+ <anchor>a7fa6101b1b387baac23a7861e2819ad9</anchor>
+ <arglist>(const T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_mem_functor3</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor3.html</anchorfile>
+ <anchor>ae63bd158d8ce2571038d4f6382a7bc51</anchor>
+ <arglist>(const T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor3.html</anchorfile>
+ <anchor>aabad5390e5b2671de1b9fbba7bf1cda6</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>const_limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor3.html</anchorfile>
+ <anchor>ac4b0ceb88bda73c90d84b1320e274621</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_const_mem_functor4</name>
+ <filename>classsigc_1_1bound__const__mem__functor4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::const_mem_functor4</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor4.html</anchorfile>
+ <anchor>a3ffc5790ded15878ce2704072791c4e9</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_mem_functor4</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor4.html</anchorfile>
+ <anchor>a06e43c95d6ace639ac169ff2d0083ebc</anchor>
+ <arglist>(const T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_mem_functor4</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor4.html</anchorfile>
+ <anchor>a1d441ea8caf2d2ff8cfca414f259b657</anchor>
+ <arglist>(const T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor4.html</anchorfile>
+ <anchor>a4db87f79d355f2ca4f5ff20d47c35ee3</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>const_limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor4.html</anchorfile>
+ <anchor>a78490633e22357be6e0a0fcf124121b5</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_const_mem_functor5</name>
+ <filename>classsigc_1_1bound__const__mem__functor5.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::const_mem_functor5</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor5.html</anchorfile>
+ <anchor>a882a71b51f303ded9d1ce172b522692a</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_mem_functor5</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor5.html</anchorfile>
+ <anchor>a3c8a1d1411eea1136fa273886688290d</anchor>
+ <arglist>(const T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_mem_functor5</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor5.html</anchorfile>
+ <anchor>a9e80ad7a6b586eb1d0cc0a4afc9ea1d4</anchor>
+ <arglist>(const T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor5.html</anchorfile>
+ <anchor>a89a861b0925989a0e845399443eee20a</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>const_limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor5.html</anchorfile>
+ <anchor>a71f8b7b3a9971d58209c3008d5e32d79</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_const_mem_functor6</name>
+ <filename>classsigc_1_1bound__const__mem__functor6.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::const_mem_functor6</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor6.html</anchorfile>
+ <anchor>a9cd70f288cac9b8d7ee9695166f3d306</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_mem_functor6</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor6.html</anchorfile>
+ <anchor>afa0adf0adf9cde73008982d2494f3d7e</anchor>
+ <arglist>(const T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_mem_functor6</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor6.html</anchorfile>
+ <anchor>a4c6a29813f84239bfc224e36d3ada58c</anchor>
+ <arglist>(const T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor6.html</anchorfile>
+ <anchor>a6bc7018118bbf55444f4d9250cf3ce65</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>const_limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor6.html</anchorfile>
+ <anchor>a152f10d5c46eb9d7d582a6e4cb747baf</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_const_mem_functor7</name>
+ <filename>classsigc_1_1bound__const__mem__functor7.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::const_mem_functor7</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor7.html</anchorfile>
+ <anchor>ae95db1c3ce4d07122e39dde2c9c5af02</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_mem_functor7</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor7.html</anchorfile>
+ <anchor>a22e365208dda5614599860d5794cb64f</anchor>
+ <arglist>(const T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_mem_functor7</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor7.html</anchorfile>
+ <anchor>a3353dd997ced3fc00f44ee2b8ccb0063</anchor>
+ <arglist>(const T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor7.html</anchorfile>
+ <anchor>a941b925ad1f628cde49bb268be8daf4a</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>const_limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__const__mem__functor7.html</anchorfile>
+ <anchor>a2b59ccc18d96b4b2ec0f6828a5c2a6e0</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_const_volatile_mem_functor0</name>
+ <filename>classsigc_1_1bound__const__volatile__mem__functor0.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::const_volatile_mem_functor0</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor0.html</anchorfile>
+ <anchor>a622322ff2ef93f0e611fd6f93f6ccdcc</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_volatile_mem_functor0</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor0.html</anchorfile>
+ <anchor>a12e99e7dc91602d1e7170a791f96a616</anchor>
+ <arglist>(const T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_volatile_mem_functor0</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor0.html</anchorfile>
+ <anchor>a364e1b19994e41acf1d99d27ffca8924</anchor>
+ <arglist>(const T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor0.html</anchorfile>
+ <anchor>abbe8bbaa0d3d7318046be146fe6fda03</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="variable">
+ <type>const_volatile_limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor0.html</anchorfile>
+ <anchor>adfea0aeaf66e1531da58af3051327949</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_const_volatile_mem_functor1</name>
+ <filename>classsigc_1_1bound__const__volatile__mem__functor1.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::const_volatile_mem_functor1</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor1.html</anchorfile>
+ <anchor>ac7a0c09914219d8baf1715675e838e59</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_volatile_mem_functor1</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor1.html</anchorfile>
+ <anchor>aaccca7de16e3da31976680b714d10e79</anchor>
+ <arglist>(const T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_volatile_mem_functor1</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor1.html</anchorfile>
+ <anchor>ac99241e0e7ba52e295f6176c03cdd741</anchor>
+ <arglist>(const T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor1.html</anchorfile>
+ <anchor>a0c520be9f25daa56ca9aba061edb7e77</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>const_volatile_limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor1.html</anchorfile>
+ <anchor>a4c6537ee7b64251b8f418047cb9fd87d</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_const_volatile_mem_functor2</name>
+ <filename>classsigc_1_1bound__const__volatile__mem__functor2.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::const_volatile_mem_functor2</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor2.html</anchorfile>
+ <anchor>a26e4bc5d2c64c1029b760fe7994fee3f</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_volatile_mem_functor2</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor2.html</anchorfile>
+ <anchor>a6a7a540b5e6a5e7d322a448904bc8881</anchor>
+ <arglist>(const T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_volatile_mem_functor2</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor2.html</anchorfile>
+ <anchor>a1b629cd2ff30fcaeb035136e190c3f4d</anchor>
+ <arglist>(const T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor2.html</anchorfile>
+ <anchor>a434acb850963a28b1a5a4662fad2b5d5</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>const_volatile_limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor2.html</anchorfile>
+ <anchor>a28eef54f97c2468f3385358b75d6cb70</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_const_volatile_mem_functor3</name>
+ <filename>classsigc_1_1bound__const__volatile__mem__functor3.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::const_volatile_mem_functor3</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor3.html</anchorfile>
+ <anchor>ae127200c20b69f91ccaf40eb60f2c448</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_volatile_mem_functor3</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor3.html</anchorfile>
+ <anchor>a3fbbc6533b408ccde3d517b1f2a38223</anchor>
+ <arglist>(const T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_volatile_mem_functor3</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor3.html</anchorfile>
+ <anchor>a7c5661cbb3554624e50c62789f339aaf</anchor>
+ <arglist>(const T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor3.html</anchorfile>
+ <anchor>af14d93c72657777d2257e3db60f20a01</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>const_volatile_limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor3.html</anchorfile>
+ <anchor>a65b0c3f640389160aa73a299aed8c512</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_const_volatile_mem_functor4</name>
+ <filename>classsigc_1_1bound__const__volatile__mem__functor4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::const_volatile_mem_functor4</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor4.html</anchorfile>
+ <anchor>a2c06c731ae9564be215802a98541d06c</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_volatile_mem_functor4</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor4.html</anchorfile>
+ <anchor>a4e0fdda617113a58f8839ab53a9fa613</anchor>
+ <arglist>(const T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_volatile_mem_functor4</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor4.html</anchorfile>
+ <anchor>a97b15b931ba6db1852011d252dd3d5f0</anchor>
+ <arglist>(const T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor4.html</anchorfile>
+ <anchor>ac1593becd15c2704535c9b50482503f9</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>const_volatile_limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor4.html</anchorfile>
+ <anchor>a52abd6d1eb7dd0919ecb6d3a667b0e18</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_const_volatile_mem_functor5</name>
+ <filename>classsigc_1_1bound__const__volatile__mem__functor5.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::const_volatile_mem_functor5</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor5.html</anchorfile>
+ <anchor>a54debcbe3edf1a9606aad9cfcc1e004c</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_volatile_mem_functor5</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor5.html</anchorfile>
+ <anchor>a178805b13affaa2b0fbaafe287cb9390</anchor>
+ <arglist>(const T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_volatile_mem_functor5</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor5.html</anchorfile>
+ <anchor>acc05a40bf47bd943c5d822b354a80ae9</anchor>
+ <arglist>(const T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor5.html</anchorfile>
+ <anchor>a7f70def3a438e6735b67f669c8fc107a</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>const_volatile_limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor5.html</anchorfile>
+ <anchor>a72dab40d6161daa1ad1655a03e5a5aa4</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_const_volatile_mem_functor6</name>
+ <filename>classsigc_1_1bound__const__volatile__mem__functor6.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::const_volatile_mem_functor6</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor6.html</anchorfile>
+ <anchor>aa8d75053aa097f0632c13bf1185f84a9</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_volatile_mem_functor6</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor6.html</anchorfile>
+ <anchor>ac5aa6dc8967fed463dd69f412ded1fd1</anchor>
+ <arglist>(const T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_volatile_mem_functor6</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor6.html</anchorfile>
+ <anchor>ae07e825b1d3ee4fa7d4dd45eb7f2fbad</anchor>
+ <arglist>(const T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor6.html</anchorfile>
+ <anchor>a9cd3a5dd70008fe70d17712cfee0f470</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>const_volatile_limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor6.html</anchorfile>
+ <anchor>abbd560d8331fbab5cd8a08afd756c8fc</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_const_volatile_mem_functor7</name>
+ <filename>classsigc_1_1bound__const__volatile__mem__functor7.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::const_volatile_mem_functor7</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor7.html</anchorfile>
+ <anchor>a48030a47276e3eede338fc78c79e5a35</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_volatile_mem_functor7</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor7.html</anchorfile>
+ <anchor>aed3adf188de8b282a4a597fb5e4a07bc</anchor>
+ <arglist>(const T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_const_volatile_mem_functor7</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor7.html</anchorfile>
+ <anchor>a6f2635a9548c06f2f5090d75df09fbf1</anchor>
+ <arglist>(const T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor7.html</anchorfile>
+ <anchor>a8fe1055d39082226d8acb3201b7b5ce7</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>const_volatile_limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__const__volatile__mem__functor7.html</anchorfile>
+ <anchor>aec37eae62ba95f04b55dd6c55c6161c1</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_mem_functor0</name>
+ <filename>classsigc_1_1bound__mem__functor0.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::mem_functor0</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__mem__functor0.html</anchorfile>
+ <anchor>a36b5479bfc091c063d44b11ad024393a</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_mem_functor0</name>
+ <anchorfile>classsigc_1_1bound__mem__functor0.html</anchorfile>
+ <anchor>a137ab7d3b66b421f664e154e3d01e66c</anchor>
+ <arglist>(T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_mem_functor0</name>
+ <anchorfile>classsigc_1_1bound__mem__functor0.html</anchorfile>
+ <anchor>a7de90a27f55055cae43df1425cc78415</anchor>
+ <arglist>(T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__mem__functor0.html</anchorfile>
+ <anchor>a8f0ea7caa1c5858b44ebdb0bcf4ba74a</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="variable">
+ <type>limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__mem__functor0.html</anchorfile>
+ <anchor>ae64f4c6596667228376947a38c4a8bb7</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_mem_functor1</name>
+ <filename>classsigc_1_1bound__mem__functor1.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::mem_functor1</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__mem__functor1.html</anchorfile>
+ <anchor>a8e460c2a0eb87dcaf263c984b4dc5888</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_mem_functor1</name>
+ <anchorfile>classsigc_1_1bound__mem__functor1.html</anchorfile>
+ <anchor>a777afe4673c9adc0798a38fc96bca7f6</anchor>
+ <arglist>(T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_mem_functor1</name>
+ <anchorfile>classsigc_1_1bound__mem__functor1.html</anchorfile>
+ <anchor>ad13235c20a9171bd24a4f8ae36577448</anchor>
+ <arglist>(T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__mem__functor1.html</anchorfile>
+ <anchor>af9d43a802f122d38d264b3f662bcfe43</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__mem__functor1.html</anchorfile>
+ <anchor>a95ae2c4525d8218569b68bbb3effbadf</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_mem_functor2</name>
+ <filename>classsigc_1_1bound__mem__functor2.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::mem_functor2</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__mem__functor2.html</anchorfile>
+ <anchor>a1b0b5d2145f50d19214ff41bd45ab978</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_mem_functor2</name>
+ <anchorfile>classsigc_1_1bound__mem__functor2.html</anchorfile>
+ <anchor>a830746b33cae370b756334e4a8cab703</anchor>
+ <arglist>(T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_mem_functor2</name>
+ <anchorfile>classsigc_1_1bound__mem__functor2.html</anchorfile>
+ <anchor>a48bc9b34469749461813061d17680ca2</anchor>
+ <arglist>(T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__mem__functor2.html</anchorfile>
+ <anchor>a09d48d61cc092e3f12c8ac4df4449596</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__mem__functor2.html</anchorfile>
+ <anchor>a423780eab9a560771ec3266ea0693117</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_mem_functor3</name>
+ <filename>classsigc_1_1bound__mem__functor3.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::mem_functor3</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__mem__functor3.html</anchorfile>
+ <anchor>a66d1aa7ad3edafd8851ee0b334f83efe</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_mem_functor3</name>
+ <anchorfile>classsigc_1_1bound__mem__functor3.html</anchorfile>
+ <anchor>a1d1dddd6a334864611f5dc3a8ece26f9</anchor>
+ <arglist>(T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_mem_functor3</name>
+ <anchorfile>classsigc_1_1bound__mem__functor3.html</anchorfile>
+ <anchor>aadbbb586e3ba0c44a25c1f3834c4c438</anchor>
+ <arglist>(T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__mem__functor3.html</anchorfile>
+ <anchor>aa61ed1a1c920069032ffd5427d24a771</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__mem__functor3.html</anchorfile>
+ <anchor>ae05cea0cbd3345abc624e545422bb47a</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_mem_functor4</name>
+ <filename>classsigc_1_1bound__mem__functor4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::mem_functor4</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__mem__functor4.html</anchorfile>
+ <anchor>aeddcfc0ce5fe38259608bfc88af37568</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_mem_functor4</name>
+ <anchorfile>classsigc_1_1bound__mem__functor4.html</anchorfile>
+ <anchor>ae15ccaa9f58865b2cd9929644aa85612</anchor>
+ <arglist>(T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_mem_functor4</name>
+ <anchorfile>classsigc_1_1bound__mem__functor4.html</anchorfile>
+ <anchor>a15b592122574775dd2c4804617e1e3dd</anchor>
+ <arglist>(T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__mem__functor4.html</anchorfile>
+ <anchor>a0a9d2fb52ef15ae8d4e56238217c0539</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__mem__functor4.html</anchorfile>
+ <anchor>aa9a90c28652fb499438e757cdc6f3be7</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_mem_functor5</name>
+ <filename>classsigc_1_1bound__mem__functor5.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::mem_functor5</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__mem__functor5.html</anchorfile>
+ <anchor>a91181f20bd393befce307655486949ad</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_mem_functor5</name>
+ <anchorfile>classsigc_1_1bound__mem__functor5.html</anchorfile>
+ <anchor>a179304173879dac0023d49e313125c8c</anchor>
+ <arglist>(T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_mem_functor5</name>
+ <anchorfile>classsigc_1_1bound__mem__functor5.html</anchorfile>
+ <anchor>aaf05ba83268cf4a55f96db281898b406</anchor>
+ <arglist>(T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__mem__functor5.html</anchorfile>
+ <anchor>aa1de6366cd9e5f0ea037287438a8072f</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__mem__functor5.html</anchorfile>
+ <anchor>a477578c56471258d6eaefb45713dbae8</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_mem_functor6</name>
+ <filename>classsigc_1_1bound__mem__functor6.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::mem_functor6</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__mem__functor6.html</anchorfile>
+ <anchor>ac92e6b87056623eeec0d09a35f41296d</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_mem_functor6</name>
+ <anchorfile>classsigc_1_1bound__mem__functor6.html</anchorfile>
+ <anchor>abff60fd63e92b1c28c2aacf1cee93508</anchor>
+ <arglist>(T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_mem_functor6</name>
+ <anchorfile>classsigc_1_1bound__mem__functor6.html</anchorfile>
+ <anchor>ab2724a290ceef4f2c279156b606e8c88</anchor>
+ <arglist>(T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__mem__functor6.html</anchorfile>
+ <anchor>ad44376814c73959398026d4e0df3d401</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__mem__functor6.html</anchorfile>
+ <anchor>a8aced07018e8f32dcc4339ce26a0e924</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_mem_functor7</name>
+ <filename>classsigc_1_1bound__mem__functor7.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::mem_functor7</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__mem__functor7.html</anchorfile>
+ <anchor>a0fcd4636185a806d055d6b885503863b</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_mem_functor7</name>
+ <anchorfile>classsigc_1_1bound__mem__functor7.html</anchorfile>
+ <anchor>a29f43e3ad8d4714c8f3477be02d62c3d</anchor>
+ <arglist>(T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_mem_functor7</name>
+ <anchorfile>classsigc_1_1bound__mem__functor7.html</anchorfile>
+ <anchor>a989011ff72d908959d2f0ad346357706</anchor>
+ <arglist>(T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__mem__functor7.html</anchorfile>
+ <anchor>ab0c379b445a5655f55f8260c699e7053</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__mem__functor7.html</anchorfile>
+ <anchor>a03e799b2af9cdc19c76e81d0bcb843ad</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_volatile_mem_functor0</name>
+ <filename>classsigc_1_1bound__volatile__mem__functor0.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::volatile_mem_functor0</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor0.html</anchorfile>
+ <anchor>a9a07aa91b2bd5ef0c4fc1a89bad5d3b0</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_volatile_mem_functor0</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor0.html</anchorfile>
+ <anchor>a4f81dd585b0aae830cd585ebb5867e20</anchor>
+ <arglist>(T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_volatile_mem_functor0</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor0.html</anchorfile>
+ <anchor>a5812d3638dc20b9fe37688d31dde8ed8</anchor>
+ <arglist>(T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor0.html</anchorfile>
+ <anchor>a5726bcc0d34cff2356976bc586d36b44</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="variable">
+ <type>volatile_limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor0.html</anchorfile>
+ <anchor>abc4357df8d4458326135e23965ba5871</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_volatile_mem_functor1</name>
+ <filename>classsigc_1_1bound__volatile__mem__functor1.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::volatile_mem_functor1</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor1.html</anchorfile>
+ <anchor>a38ee12aba5c1d6a7c608165a1137219a</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_volatile_mem_functor1</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor1.html</anchorfile>
+ <anchor>ae51c0fe21853f42cd9890f5f995f4d87</anchor>
+ <arglist>(T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_volatile_mem_functor1</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor1.html</anchorfile>
+ <anchor>af0b1a108c0080fe202b1d77cae86a7d0</anchor>
+ <arglist>(T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor1.html</anchorfile>
+ <anchor>a989556175b19d8e13c34727f231228ad</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>volatile_limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor1.html</anchorfile>
+ <anchor>a09b9ac461833030fae01249b50e5984c</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_volatile_mem_functor2</name>
+ <filename>classsigc_1_1bound__volatile__mem__functor2.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::volatile_mem_functor2</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor2.html</anchorfile>
+ <anchor>a16d5240b9bbb31ae266725d20b0f37d7</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_volatile_mem_functor2</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor2.html</anchorfile>
+ <anchor>ac3a72dc9eb316e9f096cb0a93792e368</anchor>
+ <arglist>(T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_volatile_mem_functor2</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor2.html</anchorfile>
+ <anchor>af2222c46ab0b47bd59af92ad509ef6fb</anchor>
+ <arglist>(T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor2.html</anchorfile>
+ <anchor>a5a93614f492dacd37dd1cfd94cc033b3</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>volatile_limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor2.html</anchorfile>
+ <anchor>a80858a8bbb89469136b8e476d0bae0e6</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_volatile_mem_functor3</name>
+ <filename>classsigc_1_1bound__volatile__mem__functor3.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::volatile_mem_functor3</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor3.html</anchorfile>
+ <anchor>abc967931a7ab1411e02c022035073be5</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_volatile_mem_functor3</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor3.html</anchorfile>
+ <anchor>a1f2aacad170885008a58975c8562a863</anchor>
+ <arglist>(T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_volatile_mem_functor3</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor3.html</anchorfile>
+ <anchor>a21c0be5f093ddcd084cc5ad172ceaf92</anchor>
+ <arglist>(T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor3.html</anchorfile>
+ <anchor>af5b4934a8e75fd7c32d41a989ec67f66</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>volatile_limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor3.html</anchorfile>
+ <anchor>a01d01f9945bd93e227403cdbb8271e2a</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_volatile_mem_functor4</name>
+ <filename>classsigc_1_1bound__volatile__mem__functor4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::volatile_mem_functor4</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor4.html</anchorfile>
+ <anchor>a7a30b6a2e3067254fdea50104fea8469</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_volatile_mem_functor4</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor4.html</anchorfile>
+ <anchor>a7264500594318b92a0a668fcfbbeffbc</anchor>
+ <arglist>(T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_volatile_mem_functor4</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor4.html</anchorfile>
+ <anchor>ae2385ee536e72cfbb0d945ba770f2e69</anchor>
+ <arglist>(T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor4.html</anchorfile>
+ <anchor>a22702ad82b54c77d93fb6d0481896d8f</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>volatile_limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor4.html</anchorfile>
+ <anchor>a4bb276cfe8c35645f166cde087f5d17f</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_volatile_mem_functor5</name>
+ <filename>classsigc_1_1bound__volatile__mem__functor5.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::volatile_mem_functor5</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor5.html</anchorfile>
+ <anchor>a1561f499bd4d950fd36ee43ee60db585</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_volatile_mem_functor5</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor5.html</anchorfile>
+ <anchor>a01734765e6a89bd0ab89063f130541e3</anchor>
+ <arglist>(T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_volatile_mem_functor5</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor5.html</anchorfile>
+ <anchor>af5e4db24b5ba51d92746aa3fee080d49</anchor>
+ <arglist>(T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor5.html</anchorfile>
+ <anchor>aaf0765f195ee2efef0536dfb854af9e4</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>volatile_limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor5.html</anchorfile>
+ <anchor>ae17c42b74b72c74f3a7e4d5faadaa761</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_volatile_mem_functor6</name>
+ <filename>classsigc_1_1bound__volatile__mem__functor6.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::volatile_mem_functor6</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor6.html</anchorfile>
+ <anchor>a6eeca5f695bff3c3302e4cf7d222a73d</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_volatile_mem_functor6</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor6.html</anchorfile>
+ <anchor>af79be68e9cb6c772f6d6e817bffe9656</anchor>
+ <arglist>(T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_volatile_mem_functor6</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor6.html</anchorfile>
+ <anchor>acb8a7befd300496343cf46d8520db04f</anchor>
+ <arglist>(T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor6.html</anchorfile>
+ <anchor>aa8aa3006bba7344c630f6f8adb3507d5</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>volatile_limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor6.html</anchorfile>
+ <anchor>a64c4455bc351be0f2b42dc28b03baeb9</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::bound_volatile_mem_functor7</name>
+ <filename>classsigc_1_1bound__volatile__mem__functor7.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::volatile_mem_functor7</base>
+ <member kind="typedef">
+ <type>base_type_::function_type</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor7.html</anchorfile>
+ <anchor>afce6246f9f2828a7185b3c696435d70a</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_volatile_mem_functor7</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor7.html</anchorfile>
+ <anchor>a3109683023c9e82a586660399b12769e</anchor>
+ <arglist>(T_obj &_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>bound_volatile_mem_functor7</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor7.html</anchorfile>
+ <anchor>a18f28191685aa86228328e7016b5c803</anchor>
+ <arglist>(T_obj *_A_obj, function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor7.html</anchorfile>
+ <anchor>ad1ab1d5cf45600c5369a0a119a5a89ad</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>volatile_limit_reference< T_obj ></type>
+ <name>obj_</name>
+ <anchorfile>classsigc_1_1bound__volatile__mem__functor7.html</anchorfile>
+ <anchor>a32b6c9b9aaa1e750217fc1f9d9e4b2df</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::can_deduce_result_type_with_decltype</name>
+ <filename>classsigc_1_1can__deduce__result__type__with__decltype.html</filename>
+ <templarg></templarg>
+ <member kind="variable" static="yes">
+ <type>static const bool</type>
+ <name>value</name>
+ <anchorfile>classsigc_1_1can__deduce__result__type__with__decltype.html</anchorfile>
+ <anchor>a3e390d22fe03a03bb34bb38bca1aea91</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::compose1_functor</name>
+ <filename>structsigc_1_1compose1__functor.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>adapts< T_setter ></base>
+ <member kind="typedef">
+ <type>adapts< T_setter >::adaptor_type</type>
+ <name>adaptor_type</name>
+ <anchorfile>structsigc_1_1compose1__functor.html</anchorfile>
+ <anchor>a90d506f177dca8afeaef61b6b5956541</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_getter</type>
+ <name>getter_type</name>
+ <anchorfile>structsigc_1_1compose1__functor.html</anchorfile>
+ <anchor>ad54c2d62658fb7a47da41df0ccfc618c</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>adaptor_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>structsigc_1_1compose1__functor.html</anchorfile>
+ <anchor>ab096c0a388f877d97b3812f2fcc813f9</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_setter</type>
+ <name>setter_type</name>
+ <anchorfile>structsigc_1_1compose1__functor.html</anchorfile>
+ <anchor>a86a8bc8f4926f7bb91ef362fff03a25e</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>compose1_functor</name>
+ <anchorfile>structsigc_1_1compose1__functor.html</anchorfile>
+ <anchor>a1bb831ebfb46a214a6ffda98e77ad044</anchor>
+ <arglist>(const T_setter &_A_setter, const T_getter &_A_getter)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1compose1__functor.html</anchorfile>
+ <anchor>ae7c074e7656595157b0f421028e34609</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1compose1__functor.html</anchorfile>
+ <anchor>ab32178c24587037b5ae30b8b807f5a35</anchor>
+ <arglist>(T_arg1 _A_a1)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1compose1__functor.html</anchorfile>
+ <anchor>afff816d0f3e6959be7c5f268559f3e2f</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1compose1__functor.html</anchorfile>
+ <anchor>aa53fd7a2a0b51d8c0c0e4568559292b7</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1compose1__functor.html</anchorfile>
+ <anchor>a4bc76b086fdcf3f823b055b9d6e76dab</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1compose1__functor.html</anchorfile>
+ <anchor>aebb21782ac3e60c4f817de69a316a711</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1compose1__functor.html</anchorfile>
+ <anchor>a70de905fa8c830cecf3526704c4290de</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1compose1__functor.html</anchorfile>
+ <anchor>afe1dd6cb126a8c401355b7b1c189a5d9</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)</arglist>
+ </member>
+ <member kind="variable">
+ <type>getter_type</type>
+ <name>get_</name>
+ <anchorfile>structsigc_1_1compose1__functor.html</anchorfile>
+ <anchor>abc9151caeb78b1cd79ce1eb6984dc066</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::compose2_functor</name>
+ <filename>structsigc_1_1compose2__functor.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>adapts< T_setter ></base>
+ <member kind="typedef">
+ <type>adapts< T_setter >::adaptor_type</type>
+ <name>adaptor_type</name>
+ <anchorfile>structsigc_1_1compose2__functor.html</anchorfile>
+ <anchor>ac1c9b3dc43cc75ec65fe0708fb4450d8</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_getter1</type>
+ <name>getter1_type</name>
+ <anchorfile>structsigc_1_1compose2__functor.html</anchorfile>
+ <anchor>ab7ab82eee45e8df9116a5a2b7c12c39c</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_getter2</type>
+ <name>getter2_type</name>
+ <anchorfile>structsigc_1_1compose2__functor.html</anchorfile>
+ <anchor>a75e252684d06f75f036043df56d8df69</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>adaptor_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>structsigc_1_1compose2__functor.html</anchorfile>
+ <anchor>a78ccb07f23696a452df9f61308885542</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_setter</type>
+ <name>setter_type</name>
+ <anchorfile>structsigc_1_1compose2__functor.html</anchorfile>
+ <anchor>ac3d7308c702df7378af1635281d5f7b8</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>compose2_functor</name>
+ <anchorfile>structsigc_1_1compose2__functor.html</anchorfile>
+ <anchor>a72719db97ab3ffdc0176ea3b443ffb60</anchor>
+ <arglist>(const T_setter &_A_setter, const T_getter1 &_A_getter1, const T_getter2 &_A_getter2)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1compose2__functor.html</anchorfile>
+ <anchor>a3cfcfa7d8d95962b3448ed886f3495a0</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1compose2__functor.html</anchorfile>
+ <anchor>adfcd11f81cefb39743d9467d21510c53</anchor>
+ <arglist>(T_arg1 _A_a1)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1compose2__functor.html</anchorfile>
+ <anchor>a048e0ff176de0813c190279afd7e16dd</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1compose2__functor.html</anchorfile>
+ <anchor>a48c102ded15a30326d7daefa8b817dd3</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1compose2__functor.html</anchorfile>
+ <anchor>aaa7e4c7aae30b0585039655a71ed6850</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1compose2__functor.html</anchorfile>
+ <anchor>acb668cbfa312852668695eda2198c64b</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1compose2__functor.html</anchorfile>
+ <anchor>af0cfb941c315a47381eaa288bfd87428</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1compose2__functor.html</anchorfile>
+ <anchor>af39ab33c42d6e7c715b9f5e8ba4eb556</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)</arglist>
+ </member>
+ <member kind="variable">
+ <type>getter1_type</type>
+ <name>get1_</name>
+ <anchorfile>structsigc_1_1compose2__functor.html</anchorfile>
+ <anchor>af5404ffb509175690aa896932571e8bf</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="variable">
+ <type>getter2_type</type>
+ <name>get2_</name>
+ <anchorfile>structsigc_1_1compose2__functor.html</anchorfile>
+ <anchor>af8404295ebbcb968a798c9fdf3f3d527</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::connection</name>
+ <filename>structsigc_1_1connection.html</filename>
+ <member kind="function">
+ <type></type>
+ <name>connection</name>
+ <anchorfile>structsigc_1_1connection.html</anchorfile>
+ <anchor>a95f80dbbf10fde0b851d78ec12cc2629</anchor>
+ <arglist>() noexcept</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>connection</name>
+ <anchorfile>structsigc_1_1connection.html</anchorfile>
+ <anchor>ad13d5e3331cc9b1494e0edb8fa37fdba</anchor>
+ <arglist>(const connection &c)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>connection</name>
+ <anchorfile>structsigc_1_1connection.html</anchorfile>
+ <anchor>ac8847ae94e0b05bed6c81f54f58deef3</anchor>
+ <arglist>(const slot_iterator< T_slot > &it)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>connection</name>
+ <anchorfile>structsigc_1_1connection.html</anchorfile>
+ <anchor>a124709de26781e5ffcf8bbb5dcd621ed</anchor>
+ <arglist>(slot_base &sl)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>~connection</name>
+ <anchorfile>structsigc_1_1connection.html</anchorfile>
+ <anchor>a99678ccb2be5c20719f37e469416578a</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>bool</type>
+ <name>block</name>
+ <anchorfile>structsigc_1_1connection.html</anchorfile>
+ <anchor>a581ae4f2b708cb6be7b081557864d6ec</anchor>
+ <arglist>(bool should_block=true) noexcept</arglist>
+ </member>
+ <member kind="function">
+ <type>bool</type>
+ <name>blocked</name>
+ <anchorfile>structsigc_1_1connection.html</anchorfile>
+ <anchor>a7c86964aa4b0f339db5842e6c7e604f3</anchor>
+ <arglist>() const noexcept</arglist>
+ </member>
+ <member kind="function">
+ <type>bool</type>
+ <name>connected</name>
+ <anchorfile>structsigc_1_1connection.html</anchorfile>
+ <anchor>a307b5df56439539be66f92d6e39f0bce</anchor>
+ <arglist>() const noexcept</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>disconnect</name>
+ <anchorfile>structsigc_1_1connection.html</anchorfile>
+ <anchor>a0452bd182a61650d14a9664d6297ed1b</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>bool</type>
+ <name>empty</name>
+ <anchorfile>structsigc_1_1connection.html</anchorfile>
+ <anchor>a810bdde9fbe7ad10bf9d578eebf929de</anchor>
+ <arglist>() const noexcept</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>operator bool</name>
+ <anchorfile>structsigc_1_1connection.html</anchorfile>
+ <anchor>a93215e1ea86c5fd0a465b2c4dba1257e</anchor>
+ <arglist>() noexcept</arglist>
+ </member>
+ <member kind="function">
+ <type>connection &</type>
+ <name>operator=</name>
+ <anchorfile>structsigc_1_1connection.html</anchorfile>
+ <anchor>a016094b53bafdc9ce593febb68cb00a5</anchor>
+ <arglist>(const connection &c)</arglist>
+ </member>
+ <member kind="function">
+ <type>connection &</type>
+ <name>operator=</name>
+ <anchorfile>structsigc_1_1connection.html</anchorfile>
+ <anchor>adee4ffd4b1669b4726fd9afc36330c14</anchor>
+ <arglist>(const slot_iterator< T_slot > &it)</arglist>
+ </member>
+ <member kind="function">
+ <type>bool</type>
+ <name>unblock</name>
+ <anchorfile>structsigc_1_1connection.html</anchorfile>
+ <anchor>a15abcbfa76f1e5d8601cf4ad4176ed50</anchor>
+ <arglist>() noexcept</arglist>
+ </member>
+ <member kind="function" static="yes">
+ <type>static void *</type>
+ <name>notify</name>
+ <anchorfile>structsigc_1_1connection.html</anchorfile>
+ <anchor>ad45fe90d68fe295e76e130b070e97070</anchor>
+ <arglist>(void *data)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::const_limit_reference</name>
+ <filename>classsigc_1_1const__limit__reference.html</filename>
+ <templarg></templarg>
+ <templarg>I_derives_trackable</templarg>
+ <member kind="function">
+ <type></type>
+ <name>const_limit_reference</name>
+ <anchorfile>classsigc_1_1const__limit__reference.html</anchorfile>
+ <anchor>acee8a4c09720730cd5f66696fd018b4c</anchor>
+ <arglist>(const T_type &_A_target)</arglist>
+ </member>
+ <member kind="function">
+ <type>const T_type &</type>
+ <name>invoke</name>
+ <anchorfile>classsigc_1_1const__limit__reference.html</anchorfile>
+ <anchor>abb05a4234000dbf4a256b446d3ef580d</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>const T_type &</type>
+ <name>visit</name>
+ <anchorfile>classsigc_1_1const__limit__reference.html</anchorfile>
+ <anchor>aa7486303566b2a9a74e55561083ed3d9</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::const_limit_reference< T_type, true ></name>
+ <filename>classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html</filename>
+ <templarg></templarg>
+ <member kind="function">
+ <type></type>
+ <name>const_limit_reference</name>
+ <anchorfile>classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html</anchorfile>
+ <anchor>a68f1337800c19036c81512e76e0dd6cd</anchor>
+ <arglist>(const T_type &_A_target)</arglist>
+ </member>
+ <member kind="function">
+ <type>const T_type &</type>
+ <name>invoke</name>
+ <anchorfile>classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html</anchorfile>
+ <anchor>a694136bfdbcc64717181ea2cc4714fa3</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>const trackable &</type>
+ <name>visit</name>
+ <anchorfile>classsigc_1_1const__limit__reference_3_01T__type_00_01true_01_4.html</anchorfile>
+ <anchor>abe87b8e67b8a26658a5d6f45b036721a</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::const_mem_functor0</name>
+ <filename>classsigc_1_1const__mem__functor0.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1const__mem__functor0.html</anchorfile>
+ <anchor>a5b768319ee81e2aa9e96a900e5e64996</anchor>
+ <arglist>)() const</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1const__mem__functor0.html</anchorfile>
+ <anchor>a553cd4d85524b5deea445b67773527bf</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_mem_functor0</name>
+ <anchorfile>classsigc_1_1const__mem__functor0.html</anchorfile>
+ <anchor>a49bba4c8045b8b6933b8f5a854ac98d6</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_mem_functor0</name>
+ <anchorfile>classsigc_1_1const__mem__functor0.html</anchorfile>
+ <anchor>a27895e58972642453f7b853f25a66f42</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__mem__functor0.html</anchorfile>
+ <anchor>ac388853f99f074e549c8784d1a38f46b</anchor>
+ <arglist>(const T_obj &_A_obj) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__mem__functor0.html</anchorfile>
+ <anchor>abcc08c39943577648dac107692e5b34a</anchor>
+ <arglist>(const T_obj *_A_obj) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1const__mem__functor0.html</anchorfile>
+ <anchor>a215359b20450c2afe93496826ac45c1d</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::const_mem_functor1</name>
+ <filename>classsigc_1_1const__mem__functor1.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1const__mem__functor1.html</anchorfile>
+ <anchor>a14e585a05b63c5e4790b3de75cb18c96</anchor>
+ <arglist>)(T_arg1) const</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1const__mem__functor1.html</anchorfile>
+ <anchor>a8ba6a6565b8a29812e266aa4e5261a2d</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_mem_functor1</name>
+ <anchorfile>classsigc_1_1const__mem__functor1.html</anchorfile>
+ <anchor>a2c171737e0c7dc6ae00f73f1580a976d</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_mem_functor1</name>
+ <anchorfile>classsigc_1_1const__mem__functor1.html</anchorfile>
+ <anchor>aba30421222bd496f9dec9b733fe70447</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__mem__functor1.html</anchorfile>
+ <anchor>a3a575262ae2d62c39c52280017956a95</anchor>
+ <arglist>(const T_obj &_A_obj, type_trait_take_t< T_arg1 > _A_a1) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__mem__functor1.html</anchorfile>
+ <anchor>a9e549ccae24d5a7d1741f17c09db7d5f</anchor>
+ <arglist>(const T_obj *_A_obj, type_trait_take_t< T_arg1 > _A_a1) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1const__mem__functor1.html</anchorfile>
+ <anchor>af791174008d5b58aa0f4fb42a531cc4a</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::const_mem_functor2</name>
+ <filename>classsigc_1_1const__mem__functor2.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1const__mem__functor2.html</anchorfile>
+ <anchor>a2294d014482fee6845b69ab5bc27daa9</anchor>
+ <arglist>)(T_arg1, T_arg2) const</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1const__mem__functor2.html</anchorfile>
+ <anchor>a5eaa5f2ab10ad755c89ff5b09c1e281d</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_mem_functor2</name>
+ <anchorfile>classsigc_1_1const__mem__functor2.html</anchorfile>
+ <anchor>a6265bdc51f35d8d5274bfeb8cdafc1dc</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_mem_functor2</name>
+ <anchorfile>classsigc_1_1const__mem__functor2.html</anchorfile>
+ <anchor>ab281b110d1fbba86e2d58f9607d0f0c3</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__mem__functor2.html</anchorfile>
+ <anchor>aafbf14880952214525553f4b419bf5c6</anchor>
+ <arglist>(const T_obj &_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__mem__functor2.html</anchorfile>
+ <anchor>a51c12b33270c350c8988194cb29df590</anchor>
+ <arglist>(const T_obj *_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1const__mem__functor2.html</anchorfile>
+ <anchor>a4445ff55323e94d525c1b2574ee32ddc</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::const_mem_functor3</name>
+ <filename>classsigc_1_1const__mem__functor3.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1const__mem__functor3.html</anchorfile>
+ <anchor>accd266c72527ca411756bd9a4045eac9</anchor>
+ <arglist>)(T_arg1, T_arg2, T_arg3) const</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1const__mem__functor3.html</anchorfile>
+ <anchor>ae67fd219e64f81359640873d30123c9d</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_mem_functor3</name>
+ <anchorfile>classsigc_1_1const__mem__functor3.html</anchorfile>
+ <anchor>a9921cf28137404e029e3f5d7c291021d</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_mem_functor3</name>
+ <anchorfile>classsigc_1_1const__mem__functor3.html</anchorfile>
+ <anchor>ae70cb6e5e322ef3f3a9673b1e541d2c1</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__mem__functor3.html</anchorfile>
+ <anchor>aa123c4fb39116ca1a28896cfd029b1de</anchor>
+ <arglist>(const T_obj &_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__mem__functor3.html</anchorfile>
+ <anchor>a6322fdc9cc492d4f3a2c8482e193540f</anchor>
+ <arglist>(const T_obj *_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1const__mem__functor3.html</anchorfile>
+ <anchor>ad86eb326f14c401748d0a118265e558d</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::const_mem_functor4</name>
+ <filename>classsigc_1_1const__mem__functor4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1const__mem__functor4.html</anchorfile>
+ <anchor>a775bb61661f2a7007b36f16ee106a8ad</anchor>
+ <arglist>)(T_arg1, T_arg2, T_arg3, T_arg4) const</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1const__mem__functor4.html</anchorfile>
+ <anchor>a78069750e64446199d91c0682b0915cc</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_mem_functor4</name>
+ <anchorfile>classsigc_1_1const__mem__functor4.html</anchorfile>
+ <anchor>acdde68d1638c13cd29157d1cb1bd42d2</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_mem_functor4</name>
+ <anchorfile>classsigc_1_1const__mem__functor4.html</anchorfile>
+ <anchor>a7e09703c6320542cb5f0075d371908a8</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__mem__functor4.html</anchorfile>
+ <anchor>a25b73f70e0cb8771a6fc8dd1ad521795</anchor>
+ <arglist>(const T_obj &_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__mem__functor4.html</anchorfile>
+ <anchor>a5b178876ca9fbec1fa2339819939a9e7</anchor>
+ <arglist>(const T_obj *_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1const__mem__functor4.html</anchorfile>
+ <anchor>ac0feeedacde97bd166141c285fa2c74c</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::const_mem_functor5</name>
+ <filename>classsigc_1_1const__mem__functor5.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1const__mem__functor5.html</anchorfile>
+ <anchor>aa58310b256b11e94d9a757acf60b410a</anchor>
+ <arglist>)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1const__mem__functor5.html</anchorfile>
+ <anchor>a9d952d52dade789bc38953c4c83fb425</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_mem_functor5</name>
+ <anchorfile>classsigc_1_1const__mem__functor5.html</anchorfile>
+ <anchor>a818da40f7c82d6a1fde3009d32bf3920</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_mem_functor5</name>
+ <anchorfile>classsigc_1_1const__mem__functor5.html</anchorfile>
+ <anchor>a47769ef46d8ff779df8c152acdc0d74c</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__mem__functor5.html</anchorfile>
+ <anchor>aaceffe6505aed22dd5af369231914965</anchor>
+ <arglist>(const T_obj &_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__mem__functor5.html</anchorfile>
+ <anchor>ae710c03998c58cb8f90ce75a46fab69c</anchor>
+ <arglist>(const T_obj *_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1const__mem__functor5.html</anchorfile>
+ <anchor>aeb6e66e0304e5c039d97264a3dd7d6e9</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::const_mem_functor6</name>
+ <filename>classsigc_1_1const__mem__functor6.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1const__mem__functor6.html</anchorfile>
+ <anchor>ad64803b1192e1007887f234b8c7421ac</anchor>
+ <arglist>)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1const__mem__functor6.html</anchorfile>
+ <anchor>adf81aebfa633d0bf14a0d3f5e9688561</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_mem_functor6</name>
+ <anchorfile>classsigc_1_1const__mem__functor6.html</anchorfile>
+ <anchor>a7a5e8a3a981a615a545aab358efa9472</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_mem_functor6</name>
+ <anchorfile>classsigc_1_1const__mem__functor6.html</anchorfile>
+ <anchor>a0803b89f79b60c16d87c0372be261211</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__mem__functor6.html</anchorfile>
+ <anchor>a8657b806cb2eeb7e43f0a09f6556c514</anchor>
+ <arglist>(const T_obj &_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__mem__functor6.html</anchorfile>
+ <anchor>a023fd4cb845234b50c5dee1f4147cde9</anchor>
+ <arglist>(const T_obj *_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1const__mem__functor6.html</anchorfile>
+ <anchor>a665c77c3da00d474d6d999c394801a98</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::const_mem_functor7</name>
+ <filename>classsigc_1_1const__mem__functor7.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1const__mem__functor7.html</anchorfile>
+ <anchor>a73af81d23d0fa816b8ef00acb1970d43</anchor>
+ <arglist>)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1const__mem__functor7.html</anchorfile>
+ <anchor>a724b8b210493e0d3cf06b5a393b91546</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_mem_functor7</name>
+ <anchorfile>classsigc_1_1const__mem__functor7.html</anchorfile>
+ <anchor>add4d7f74905c6bc20afc6f7681f367c0</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_mem_functor7</name>
+ <anchorfile>classsigc_1_1const__mem__functor7.html</anchorfile>
+ <anchor>a0538bba01694fc13456fcee0e96d8f34</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__mem__functor7.html</anchorfile>
+ <anchor>ab49dc9f302ef22e4b76043d9bc2f5062</anchor>
+ <arglist>(const T_obj &_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__mem__functor7.html</anchorfile>
+ <anchor>a53f19248e5b61460759d7cdbf41ca21b</anchor>
+ <arglist>(const T_obj *_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1const__mem__functor7.html</anchorfile>
+ <anchor>a255588607e165db8bd25c3bb8d7e1fbe</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::const_reference_wrapper</name>
+ <filename>structsigc_1_1const__reference__wrapper.html</filename>
+ <templarg></templarg>
+ <member kind="function">
+ <type></type>
+ <name>const_reference_wrapper</name>
+ <anchorfile>structsigc_1_1const__reference__wrapper.html</anchorfile>
+ <anchor>a249ae888fb9be126598d81ce339fbf81</anchor>
+ <arglist>(const T_type &v)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>operator const T_type &</name>
+ <anchorfile>structsigc_1_1const__reference__wrapper.html</anchorfile>
+ <anchor>a2cf7a981855668dfb69e98cfaa6eb779</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="variable">
+ <type>const T_type &</type>
+ <name>value_</name>
+ <anchorfile>structsigc_1_1const__reference__wrapper.html</anchorfile>
+ <anchor>aaaba3da60073e485144be648f8c4f69f</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::const_volatile_limit_reference</name>
+ <filename>classsigc_1_1const__volatile__limit__reference.html</filename>
+ <templarg></templarg>
+ <templarg>I_derives_trackable</templarg>
+ <member kind="function">
+ <type></type>
+ <name>const_volatile_limit_reference</name>
+ <anchorfile>classsigc_1_1const__volatile__limit__reference.html</anchorfile>
+ <anchor>a9a01809bae79cb1b13ee50ce9d84dcb8</anchor>
+ <arglist>(const T_type &_A_target)</arglist>
+ </member>
+ <member kind="function">
+ <type>const volatile T_type &</type>
+ <name>invoke</name>
+ <anchorfile>classsigc_1_1const__volatile__limit__reference.html</anchorfile>
+ <anchor>ac09d022e8991a946d49a714df8b2f1c7</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>const T_type &</type>
+ <name>visit</name>
+ <anchorfile>classsigc_1_1const__volatile__limit__reference.html</anchorfile>
+ <anchor>a41c17ef86e8c65998ba42097c7ad5f09</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::const_volatile_limit_reference< T_type, true ></name>
+ <filename>classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html</filename>
+ <templarg></templarg>
+ <member kind="function">
+ <type></type>
+ <name>const_volatile_limit_reference</name>
+ <anchorfile>classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html</anchorfile>
+ <anchor>a94bf04779d798bd2737c521d20655122</anchor>
+ <arglist>(const T_type &_A_target)</arglist>
+ </member>
+ <member kind="function">
+ <type>const volatile T_type &</type>
+ <name>invoke</name>
+ <anchorfile>classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html</anchorfile>
+ <anchor>a0a44e756c7478717ef8b34fb5b0c7004</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>const trackable &</type>
+ <name>visit</name>
+ <anchorfile>classsigc_1_1const__volatile__limit__reference_3_01T__type_00_01true_01_4.html</anchorfile>
+ <anchor>a332d07b8ef0005163f02df234f014814</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::const_volatile_mem_functor0</name>
+ <filename>classsigc_1_1const__volatile__mem__functor0.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor0.html</anchorfile>
+ <anchor>a3247f7d0e3804ff455e0996b969f6c59</anchor>
+ <arglist>)() const volatile</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor0.html</anchorfile>
+ <anchor>ab8e419ef5ad21d6230a306cd7d910df9</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_volatile_mem_functor0</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor0.html</anchorfile>
+ <anchor>a8eec4c4ff04b8d5ef7c184e853ea0486</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_volatile_mem_functor0</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor0.html</anchorfile>
+ <anchor>ab20dd00a6c8908a8ebd7846985d71856</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor0.html</anchorfile>
+ <anchor>adfd64d64707c012329915edf19190772</anchor>
+ <arglist>(const T_obj &_A_obj) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor0.html</anchorfile>
+ <anchor>a86005d47b02e980c90d135a636e21674</anchor>
+ <arglist>(const T_obj *_A_obj) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor0.html</anchorfile>
+ <anchor>ae0f88c6683fb175845f5f804c2c04ec8</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::const_volatile_mem_functor1</name>
+ <filename>classsigc_1_1const__volatile__mem__functor1.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor1.html</anchorfile>
+ <anchor>acc367f8d6ee646c370623650a7ed6cde</anchor>
+ <arglist>)(T_arg1) const volatile</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor1.html</anchorfile>
+ <anchor>adeaf82cc2aff607efe2a51945d6b8565</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_volatile_mem_functor1</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor1.html</anchorfile>
+ <anchor>a25a541c4bef874a6b2d177a3be7ab988</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_volatile_mem_functor1</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor1.html</anchorfile>
+ <anchor>aa8cb4ad934ac610ffe3425cbe799ba8d</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor1.html</anchorfile>
+ <anchor>a715b1d5c56a537cbd397875e8eba532d</anchor>
+ <arglist>(const T_obj &_A_obj, type_trait_take_t< T_arg1 > _A_a1) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor1.html</anchorfile>
+ <anchor>a9af06968e1db65f5bd136175e10d250f</anchor>
+ <arglist>(const T_obj *_A_obj, type_trait_take_t< T_arg1 > _A_a1) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor1.html</anchorfile>
+ <anchor>af9da27522999030f09c718dbe164f1f6</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::const_volatile_mem_functor2</name>
+ <filename>classsigc_1_1const__volatile__mem__functor2.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor2.html</anchorfile>
+ <anchor>ac46d1e343e669092d6bb24aa8b5d5dbb</anchor>
+ <arglist>)(T_arg1, T_arg2) const volatile</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor2.html</anchorfile>
+ <anchor>a0d143bb32627f7a0c17270321df8145f</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_volatile_mem_functor2</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor2.html</anchorfile>
+ <anchor>ad99060cf675fb65cbc00f2b8e9ec3068</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_volatile_mem_functor2</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor2.html</anchorfile>
+ <anchor>ada3da9a8dd692377c90abbfa9bcfe73a</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor2.html</anchorfile>
+ <anchor>a467a45cf9bc54bed0f3c5bade3329067</anchor>
+ <arglist>(const T_obj &_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor2.html</anchorfile>
+ <anchor>a9d024cf10df876df77183e1fb79a52ec</anchor>
+ <arglist>(const T_obj *_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor2.html</anchorfile>
+ <anchor>aac7f64e6cff784ecd6700d0448d8e796</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::const_volatile_mem_functor3</name>
+ <filename>classsigc_1_1const__volatile__mem__functor3.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor3.html</anchorfile>
+ <anchor>a472ab7835e2b6792a108f4fcc80d4669</anchor>
+ <arglist>)(T_arg1, T_arg2, T_arg3) const volatile</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor3.html</anchorfile>
+ <anchor>ad2056f73eed4664ff41f5e673a2276f0</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_volatile_mem_functor3</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor3.html</anchorfile>
+ <anchor>af284f300a6b3696f6379dcc9ed97a744</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_volatile_mem_functor3</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor3.html</anchorfile>
+ <anchor>aa586f24064b6a5c8b69c963fff614d04</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor3.html</anchorfile>
+ <anchor>a4af918f707067763bb2031d8758991d5</anchor>
+ <arglist>(const T_obj &_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor3.html</anchorfile>
+ <anchor>a47374a80a3a61b69e39478ca9a4a4776</anchor>
+ <arglist>(const T_obj *_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor3.html</anchorfile>
+ <anchor>a6ffedac451ab4f525bd7c9df0b83cf2c</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::const_volatile_mem_functor4</name>
+ <filename>classsigc_1_1const__volatile__mem__functor4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor4.html</anchorfile>
+ <anchor>ace3cb54e6265ebe06ee2995dd01f2540</anchor>
+ <arglist>)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor4.html</anchorfile>
+ <anchor>a8e38a0816627c7ad4fd48278d287f863</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_volatile_mem_functor4</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor4.html</anchorfile>
+ <anchor>aad7b7f5037a0c8d13668f9c350e010ee</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_volatile_mem_functor4</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor4.html</anchorfile>
+ <anchor>a0ffe59d6392c736e6d14c43a4bfa26e5</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor4.html</anchorfile>
+ <anchor>a7cd0900e7e3c8523503e037e7c696f5d</anchor>
+ <arglist>(const T_obj &_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor4.html</anchorfile>
+ <anchor>a589c68eddffeb3399838d2af7f5b6d19</anchor>
+ <arglist>(const T_obj *_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor4.html</anchorfile>
+ <anchor>a0714aabc799c5d41af988650fec71410</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::const_volatile_mem_functor5</name>
+ <filename>classsigc_1_1const__volatile__mem__functor5.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor5.html</anchorfile>
+ <anchor>a1d49a5a7086d41d1db2e40aed1273631</anchor>
+ <arglist>)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor5.html</anchorfile>
+ <anchor>a42d6cd140b98358c1d12c90b975ad2b1</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_volatile_mem_functor5</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor5.html</anchorfile>
+ <anchor>afe48307086c70740f39f58488a3cbdb5</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_volatile_mem_functor5</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor5.html</anchorfile>
+ <anchor>a13787a099e237b44280ddbe9b8d97a04</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor5.html</anchorfile>
+ <anchor>a8d74b334440d1c9add3a358cd1913b11</anchor>
+ <arglist>(const T_obj &_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor5.html</anchorfile>
+ <anchor>a7b1fde7647e7e936b29c97797835ca7b</anchor>
+ <arglist>(const T_obj *_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor5.html</anchorfile>
+ <anchor>a785d079f14f42cafd052639a1ebdaeb9</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::const_volatile_mem_functor6</name>
+ <filename>classsigc_1_1const__volatile__mem__functor6.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor6.html</anchorfile>
+ <anchor>af8da04ac5f6e2252f963f4f4bb87c9fd</anchor>
+ <arglist>)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor6.html</anchorfile>
+ <anchor>a9f866db08b59a0960875f7608a0c93f0</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_volatile_mem_functor6</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor6.html</anchorfile>
+ <anchor>aa921f2d1cea8ddd987cdaa8df6479fab</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_volatile_mem_functor6</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor6.html</anchorfile>
+ <anchor>a09704c72e9b0353b04776522edefd57e</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor6.html</anchorfile>
+ <anchor>a5cf522fd8072a8f77e56cae87d65892f</anchor>
+ <arglist>(const T_obj &_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor6.html</anchorfile>
+ <anchor>adff33012b1d7a20cb39c41c19b1db9a5</anchor>
+ <arglist>(const T_obj *_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor6.html</anchorfile>
+ <anchor>aed412f2606f91f9c11567c37ae6175bc</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::const_volatile_mem_functor7</name>
+ <filename>classsigc_1_1const__volatile__mem__functor7.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor7.html</anchorfile>
+ <anchor>a7e3bac9b817c848b96e9d1b257be1de5</anchor>
+ <arglist>)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor7.html</anchorfile>
+ <anchor>a25cb7e6ed71406c5b91ab2696ad8e623</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_volatile_mem_functor7</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor7.html</anchorfile>
+ <anchor>ac71290a7277b022f8a8d7abc4158a7ae</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>const_volatile_mem_functor7</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor7.html</anchorfile>
+ <anchor>a95dcac66fbdb4c3b92682a1ddaa0309c</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor7.html</anchorfile>
+ <anchor>a9cb200c4d7a95edf269ede2b9c7ab060</anchor>
+ <arglist>(const T_obj &_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor7.html</anchorfile>
+ <anchor>a1c9477eed5eef826a4666817aee9ea25</anchor>
+ <arglist>(const T_obj *_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1const__volatile__mem__functor7.html</anchorfile>
+ <anchor>a3f19b8bff74776f040492d3410c54fa1</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::deduce_result_type</name>
+ <filename>structsigc_1_1deduce__result__type.html</filename>
+ <templarg></templarg>
+ <templarg>T_args</templarg>
+ <member kind="typedef">
+ <type>decltype(test< T_functor >())</type>
+ <name>type</name>
+ <anchorfile>structsigc_1_1deduce__result__type.html</anchorfile>
+ <anchor>a529a6b7809ea3ad1a2d4392b9ffcec42</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function" static="yes">
+ <type>static U_functor::template deduce_result_type< T_args... >::type</type>
+ <name>test</name>
+ <anchorfile>structsigc_1_1deduce__result__type.html</anchorfile>
+ <anchor>a46816d343f0924170208d220b7e599f4</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function" static="yes">
+ <type>static functor_trait< T_functor >::result_type</type>
+ <name>test</name>
+ <anchorfile>structsigc_1_1deduce__result__type.html</anchorfile>
+ <anchor>ab9356fdb52cf08ca8eded48bae5e5bdb</anchor>
+ <arglist>()</arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::exception_catch_functor</name>
+ <filename>structsigc_1_1exception__catch__functor.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::adapts</base>
+ <member kind="typedef">
+ <type>adapts< T_functor >::adaptor_type</type>
+ <name>adaptor_type</name>
+ <anchorfile>structsigc_1_1exception__catch__functor.html</anchorfile>
+ <anchor>a5dc4ecab205c7ad5c3954c2572d4cc08</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>structsigc_1_1exception__catch__functor.html</anchorfile>
+ <anchor>a498f5575ae283594cfe03288fab54fdf</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>exception_catch_functor</name>
+ <anchorfile>structsigc_1_1exception__catch__functor.html</anchorfile>
+ <anchor>acefeea54e1d83cb64844a956598918fd</anchor>
+ <arglist>(const T_functor &_A_func, const T_catcher &_A_catcher)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1exception__catch__functor.html</anchorfile>
+ <anchor>a9f6b5068be1af2623e2aef727f2b73db</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1exception__catch__functor.html</anchorfile>
+ <anchor>a5472e0c6cdc3e9f0994bcd6676e7ed0f</anchor>
+ <arglist>(T_arg1 _A_a1)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1exception__catch__functor.html</anchorfile>
+ <anchor>a00ce284a875f728da4db0b401f40c561</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1exception__catch__functor.html</anchorfile>
+ <anchor>aa20b567a833cdc29517f4161be5bb8b2</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1exception__catch__functor.html</anchorfile>
+ <anchor>a5bb82bbe1b0491cd5c53680eb5cd6b03</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1exception__catch__functor.html</anchorfile>
+ <anchor>aae43815dd495f34d8d519fb2dcf26102</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1exception__catch__functor.html</anchorfile>
+ <anchor>abc125711f5e27d38b3762e18069289ff</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1exception__catch__functor.html</anchorfile>
+ <anchor>a07ae1354aa93e8421c705a21cbb85ad8</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)</arglist>
+ </member>
+ <member kind="variable">
+ <type>T_catcher</type>
+ <name>catcher_</name>
+ <anchorfile>structsigc_1_1exception__catch__functor.html</anchorfile>
+ <anchor>af94123d76a61a13258893ed575a019b0</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::exception_catch_functor< T_functor, T_catcher, void ></name>
+ <filename>structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::adapts</base>
+ <member kind="typedef">
+ <type>adapts< T_functor >::adaptor_type</type>
+ <name>adaptor_type</name>
+ <anchorfile>structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html</anchorfile>
+ <anchor>aa9803c7bd355ae0674dbfabf346676c0</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>void</type>
+ <name>result_type</name>
+ <anchorfile>structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html</anchorfile>
+ <anchor>a06506e0d4da26682740b7f4f9aec80d5</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>exception_catch_functor</name>
+ <anchorfile>structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html</anchorfile>
+ <anchor>a84b167dc0dd520253776c55eb711c461</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>exception_catch_functor</name>
+ <anchorfile>structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html</anchorfile>
+ <anchor>a08a5ce7a94a0646e92c5eb8fb6b7d5f3</anchor>
+ <arglist>(const T_functor &_A_func, const T_catcher &_A_catcher)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>~exception_catch_functor</name>
+ <anchorfile>structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html</anchorfile>
+ <anchor>a1537e7d0175046d65522bd960149bb62</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html</anchorfile>
+ <anchor>a24e842daf8e8d756e2b77ceb47c55c14</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html</anchorfile>
+ <anchor>ade12d3049fdb07307d0852aa9a90f1b6</anchor>
+ <arglist>(T_arg1 _A_a1)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html</anchorfile>
+ <anchor>a552ee97ff7ee248d75ecd0241d379d31</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html</anchorfile>
+ <anchor>a4062190405963d2bf806219d3480b2dd</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html</anchorfile>
+ <anchor>a68bec561e3c051fc3551965ccbad4398</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html</anchorfile>
+ <anchor>a1eb6fb5783d65d904474f6ffe14ace7b</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html</anchorfile>
+ <anchor>a4c24ffa31304c0647b0d29cba07ffe3a</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html</anchorfile>
+ <anchor>ab4d0d68e2dd1d356ff932ac2ca846a0c</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)</arglist>
+ </member>
+ <member kind="variable">
+ <type>T_catcher</type>
+ <name>catcher_</name>
+ <anchorfile>structsigc_1_1exception__catch__functor_3_01T__functor_00_01T__catcher_00_01void_01_4.html</anchorfile>
+ <anchor>acc50467493545db2b55e638f7ac28c42</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::functor_base</name>
+ <filename>structsigc_1_1functor__base.html</filename>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::functor_trait</name>
+ <filename>structsigc_1_1functor__trait.html</filename>
+ <templarg></templarg>
+ <templarg>I_derives_functor_base</templarg>
+ <templarg>I_can_use_decltype</templarg>
+ <member kind="typedef">
+ <type>T_functor</type>
+ <name>functor_type</name>
+ <anchorfile>structsigc_1_1functor__trait.html</anchorfile>
+ <anchor>ac779b3d3d04e78d57b6b2ae4545b1667</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>void</type>
+ <name>result_type</name>
+ <anchorfile>structsigc_1_1functor__trait.html</anchorfile>
+ <anchor>af1324bf0d3cec3d1f2e39e932b228d6d</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::hide_functor</name>
+ <filename>structsigc_1_1hide__functor.html</filename>
+ <templarg>I_location</templarg>
+ <templarg></templarg>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::hide_functor< 0, T_functor ></name>
+ <filename>structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html</filename>
+ <templarg></templarg>
+ <base>sigc::adapts</base>
+ <member kind="typedef">
+ <type>adapts< T_functor >::adaptor_type</type>
+ <name>adaptor_type</name>
+ <anchorfile>structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html</anchorfile>
+ <anchor>a33b1c4635aad21aac771627a9a9fe60f</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>adaptor_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html</anchorfile>
+ <anchor>af5b5ee49bb277471b5bc8e3769d0dcb7</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>hide_functor</name>
+ <anchorfile>structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html</anchorfile>
+ <anchor>a7d5504f337ab7a4b6f709219c9e98222</anchor>
+ <arglist>(const T_functor &_A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html</anchorfile>
+ <anchor>a556774f196a4ec5569e8404ba8ae1539</anchor>
+ <arglist>(T_arg1)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html</anchorfile>
+ <anchor>ad6b459b35d0bf0e337fdef4780e68840</anchor>
+ <arglist>(T_arg1, T_arg2 _A_a2)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html</anchorfile>
+ <anchor>a5390f82ac4049f2a22ef1f4896a508dd</anchor>
+ <arglist>(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html</anchorfile>
+ <anchor>a587bc5d423b0b38722764c9f0792e73c</anchor>
+ <arglist>(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html</anchorfile>
+ <anchor>a9c8415cad0f615bb1a24cf8e8a985cf7</anchor>
+ <arglist>(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html</anchorfile>
+ <anchor>a62027eafacff15f5f7efaefd204f1908</anchor>
+ <arglist>(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1hide__functor_3_010_00_01T__functor_01_4.html</anchorfile>
+ <anchor>a599128c72562bd8de98c37f046471080</anchor>
+ <arglist>(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)</arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::hide_functor<-1, T_functor ></name>
+ <filename>structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html</filename>
+ <templarg></templarg>
+ <base>sigc::adapts</base>
+ <member kind="typedef">
+ <type>adapts< T_functor >::adaptor_type</type>
+ <name>adaptor_type</name>
+ <anchorfile>structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html</anchorfile>
+ <anchor>a1f2c49ddcd02a3b7f240f0d0e6f0eec5</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>adaptor_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html</anchorfile>
+ <anchor>a72ea0ce5ad7cf4f9e0e7b160d830c5a4</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>hide_functor</name>
+ <anchorfile>structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html</anchorfile>
+ <anchor>a4c8d774e447991a6a920b9f3fca63205</anchor>
+ <arglist>(const T_functor &_A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html</anchorfile>
+ <anchor>a3ab506b688835f9545dc018142cc728e</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html</anchorfile>
+ <anchor>a4c9d0e81c0dacb65443b810ba90f81b7</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html</anchorfile>
+ <anchor>a1b14612df4daabfa76ddb5aa9d48c023</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html</anchorfile>
+ <anchor>a576f3873a5e2444cec82b04f82b1e01e</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html</anchorfile>
+ <anchor>a8a00e3b27c18520ff693b379aa3db3da</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html</anchorfile>
+ <anchor>af4b6fe456f259ae4a9973c2feaebb9f5</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1hide__functor_3-1_00_01T__functor_01_4.html</anchorfile>
+ <anchor>a0b2aed34c7b1c58fc9735ec4578bd6c2</anchor>
+ <arglist>(T_arg1)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::limit_reference</name>
+ <filename>classsigc_1_1limit__reference.html</filename>
+ <templarg></templarg>
+ <templarg>I_derives_trackable</templarg>
+ <member kind="function">
+ <type></type>
+ <name>limit_reference</name>
+ <anchorfile>classsigc_1_1limit__reference.html</anchorfile>
+ <anchor>a58bf17e1eaa63d86336c831fa885bc66</anchor>
+ <arglist>(T_type &_A_target)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_type &</type>
+ <name>invoke</name>
+ <anchorfile>classsigc_1_1limit__reference.html</anchorfile>
+ <anchor>affd2902cd78ccdae45c499058c83e992</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>const T_type &</type>
+ <name>visit</name>
+ <anchorfile>classsigc_1_1limit__reference.html</anchorfile>
+ <anchor>affeb3929fdc606c8fb7f8f29fa6fd12d</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::limit_reference< T_type, true ></name>
+ <filename>classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html</filename>
+ <templarg></templarg>
+ <member kind="function">
+ <type></type>
+ <name>limit_reference</name>
+ <anchorfile>classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html</anchorfile>
+ <anchor>a26ef98ef1f11a4b5891d426e9722c2c8</anchor>
+ <arglist>(T_type &_A_target)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_type &</type>
+ <name>invoke</name>
+ <anchorfile>classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html</anchorfile>
+ <anchor>a6c8067da8b8c15361127ad25efab6903</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>const trackable &</type>
+ <name>visit</name>
+ <anchorfile>classsigc_1_1limit__reference_3_01T__type_00_01true_01_4.html</anchorfile>
+ <anchor>a85e56a8140929d71b2bdbd091e348c3a</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::mem_functor0</name>
+ <filename>classsigc_1_1mem__functor0.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1mem__functor0.html</anchorfile>
+ <anchor>a2b54ee0f1d0b0ca4f25707c85a5d4bab</anchor>
+ <arglist>)()</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1mem__functor0.html</anchorfile>
+ <anchor>aa679f73c7b786540686c110628a71dde</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>mem_functor0</name>
+ <anchorfile>classsigc_1_1mem__functor0.html</anchorfile>
+ <anchor>ad598cd301fc54f3aa4da2b9e3c16bc81</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>mem_functor0</name>
+ <anchorfile>classsigc_1_1mem__functor0.html</anchorfile>
+ <anchor>a5655f48c6f36716dc15daf584f20d51c</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1mem__functor0.html</anchorfile>
+ <anchor>a51d5213c9d41b51e3b8cca705bd801cc</anchor>
+ <arglist>(T_obj &_A_obj) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1mem__functor0.html</anchorfile>
+ <anchor>a0a8b70a8f59ddbdc3f1a9892c634bf48</anchor>
+ <arglist>(T_obj *_A_obj) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1mem__functor0.html</anchorfile>
+ <anchor>a1f7b51d412900f55e155ecdd848fa283</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::mem_functor1</name>
+ <filename>classsigc_1_1mem__functor1.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1mem__functor1.html</anchorfile>
+ <anchor>a4f10314fc4d7811e126aa0d8dc9fea8c</anchor>
+ <arglist>)(T_arg1)</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1mem__functor1.html</anchorfile>
+ <anchor>a7c7ab28530e2f678eae87772253df709</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>mem_functor1</name>
+ <anchorfile>classsigc_1_1mem__functor1.html</anchorfile>
+ <anchor>ab97c2206275025d8d1e7665c12322eba</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>mem_functor1</name>
+ <anchorfile>classsigc_1_1mem__functor1.html</anchorfile>
+ <anchor>a63230b348e410f7d2f245df1f2af019a</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1mem__functor1.html</anchorfile>
+ <anchor>a55a370a320def89e80aa37141c101c98</anchor>
+ <arglist>(T_obj &_A_obj, type_trait_take_t< T_arg1 > _A_a1) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1mem__functor1.html</anchorfile>
+ <anchor>a11fa461ba0bbddc9e5a7dd687e90591b</anchor>
+ <arglist>(T_obj *_A_obj, type_trait_take_t< T_arg1 > _A_a1) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1mem__functor1.html</anchorfile>
+ <anchor>af5981be86ea36d59e86234ef5cd2b5a4</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::mem_functor2</name>
+ <filename>classsigc_1_1mem__functor2.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1mem__functor2.html</anchorfile>
+ <anchor>aa584cfe15bb8dc5b2931d2bfd034c118</anchor>
+ <arglist>)(T_arg1, T_arg2)</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1mem__functor2.html</anchorfile>
+ <anchor>a9080e942d35d226ea6f9dda097342f07</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>mem_functor2</name>
+ <anchorfile>classsigc_1_1mem__functor2.html</anchorfile>
+ <anchor>a691e21d47b7a54b67605812f7e089299</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>mem_functor2</name>
+ <anchorfile>classsigc_1_1mem__functor2.html</anchorfile>
+ <anchor>aeee1c7f263f8d7e7b6fa9be0156878fe</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1mem__functor2.html</anchorfile>
+ <anchor>a6fe02ecb626919c1149888b03fde552e</anchor>
+ <arglist>(T_obj &_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1mem__functor2.html</anchorfile>
+ <anchor>ad5d0f74803537d1ed8b9678ac2da57d5</anchor>
+ <arglist>(T_obj *_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1mem__functor2.html</anchorfile>
+ <anchor>aa4b00e1d6bb65c1c1791d314b5dcb4d6</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::mem_functor3</name>
+ <filename>classsigc_1_1mem__functor3.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1mem__functor3.html</anchorfile>
+ <anchor>a8da99a5dcfe5ae1cecd6ce93ab91b929</anchor>
+ <arglist>)(T_arg1, T_arg2, T_arg3)</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1mem__functor3.html</anchorfile>
+ <anchor>af620103fa36aa86fb539843f7f730e01</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>mem_functor3</name>
+ <anchorfile>classsigc_1_1mem__functor3.html</anchorfile>
+ <anchor>abc94be96c346537bca09c73a342f5ccd</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>mem_functor3</name>
+ <anchorfile>classsigc_1_1mem__functor3.html</anchorfile>
+ <anchor>af22e274e905262144832ca9683d8823f</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1mem__functor3.html</anchorfile>
+ <anchor>a12319d24e245cf126c130de8202d91bf</anchor>
+ <arglist>(T_obj &_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1mem__functor3.html</anchorfile>
+ <anchor>ae7496f451661d60b287d528a7cfcaf82</anchor>
+ <arglist>(T_obj *_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1mem__functor3.html</anchorfile>
+ <anchor>ac7ed881bf6b6ef8c7ed418ad3bfc0ccc</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::mem_functor4</name>
+ <filename>classsigc_1_1mem__functor4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1mem__functor4.html</anchorfile>
+ <anchor>a9dcf1ef95187c2588ecf2abb089cc7c8</anchor>
+ <arglist>)(T_arg1, T_arg2, T_arg3, T_arg4)</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1mem__functor4.html</anchorfile>
+ <anchor>a79bf0a3c25dbe6eb07829ee55ce5d664</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>mem_functor4</name>
+ <anchorfile>classsigc_1_1mem__functor4.html</anchorfile>
+ <anchor>a9774f0ab47d023f5bccdb9960c4fcdee</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>mem_functor4</name>
+ <anchorfile>classsigc_1_1mem__functor4.html</anchorfile>
+ <anchor>a4f7841b2ccd26fac6c21bf04fc524e08</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1mem__functor4.html</anchorfile>
+ <anchor>a37b49e119c9be15f15362fe44eadc6a2</anchor>
+ <arglist>(T_obj &_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1mem__functor4.html</anchorfile>
+ <anchor>aef140dac7b4876793fac8a006aad0a62</anchor>
+ <arglist>(T_obj *_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1mem__functor4.html</anchorfile>
+ <anchor>a28282d9285ca1a2075fd8041905a6302</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::mem_functor5</name>
+ <filename>classsigc_1_1mem__functor5.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1mem__functor5.html</anchorfile>
+ <anchor>a66e9bb0c9829b13af029ee2127b54eb5</anchor>
+ <arglist>)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1mem__functor5.html</anchorfile>
+ <anchor>a3e0587ce338328d42f44c4e5f79be6ed</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>mem_functor5</name>
+ <anchorfile>classsigc_1_1mem__functor5.html</anchorfile>
+ <anchor>a9048a4a2216e20f9f34380020f5b67ec</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>mem_functor5</name>
+ <anchorfile>classsigc_1_1mem__functor5.html</anchorfile>
+ <anchor>a01bdff47bf4aed8c52fdfd5520fdf3cf</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1mem__functor5.html</anchorfile>
+ <anchor>af1ce121edd0248d104f95e239af683bd</anchor>
+ <arglist>(T_obj &_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1mem__functor5.html</anchorfile>
+ <anchor>a7ad7a4d81470125047755dfa8509c6dc</anchor>
+ <arglist>(T_obj *_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1mem__functor5.html</anchorfile>
+ <anchor>a73a58b713dccc6a48b0083063b0df719</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::mem_functor6</name>
+ <filename>classsigc_1_1mem__functor6.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1mem__functor6.html</anchorfile>
+ <anchor>a202287b72f6213f64a696b185fb90268</anchor>
+ <arglist>)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1mem__functor6.html</anchorfile>
+ <anchor>af80425ff57ca2115cba771c275f49e36</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>mem_functor6</name>
+ <anchorfile>classsigc_1_1mem__functor6.html</anchorfile>
+ <anchor>aaa43195f4b4e39c76c10478539d35172</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>mem_functor6</name>
+ <anchorfile>classsigc_1_1mem__functor6.html</anchorfile>
+ <anchor>aabc6bb723e0831e27a0a9131525d96bc</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1mem__functor6.html</anchorfile>
+ <anchor>a4a322216c1783eb8ad7f63972b3a1164</anchor>
+ <arglist>(T_obj &_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1mem__functor6.html</anchorfile>
+ <anchor>afc40dbe8ea11726018dfa7c1ca435f3d</anchor>
+ <arglist>(T_obj *_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1mem__functor6.html</anchorfile>
+ <anchor>af07a44f7435cf15228903b0868fac956</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::mem_functor7</name>
+ <filename>classsigc_1_1mem__functor7.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1mem__functor7.html</anchorfile>
+ <anchor>a408f0afec5b4c750ca8e1bdab0f8b535</anchor>
+ <arglist>)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1mem__functor7.html</anchorfile>
+ <anchor>a967b5f6572e988ea0833818b993745f9</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>mem_functor7</name>
+ <anchorfile>classsigc_1_1mem__functor7.html</anchorfile>
+ <anchor>afbb9b8ecaa25e0dd85c0f3d539f198b4</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>mem_functor7</name>
+ <anchorfile>classsigc_1_1mem__functor7.html</anchorfile>
+ <anchor>a79de1ccebb568e82b7f7a67ab85e4dc6</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1mem__functor7.html</anchorfile>
+ <anchor>ad8e9031dc12742265d834a5529b1f00d</anchor>
+ <arglist>(T_obj &_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1mem__functor7.html</anchorfile>
+ <anchor>ab95293e358caf96b5dbf123f024eed8d</anchor>
+ <arglist>(T_obj *_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1mem__functor7.html</anchorfile>
+ <anchor>a779c41d697c3b80d08a06cbcc9a5ea25</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::nil</name>
+ <filename>structsigc_1_1nil.html</filename>
+ </compound>
+ <compound kind="class">
+ <name>sigc::pointer_functor0</name>
+ <filename>classsigc_1_1pointer__functor0.html</filename>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1pointer__functor0.html</anchorfile>
+ <anchor>af44316e53e33b4184ca151b6b11c70e5</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>pointer_functor0</name>
+ <anchorfile>classsigc_1_1pointer__functor0.html</anchorfile>
+ <anchor>afdb67f682e7b9190f646eed879dcfbe4</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>pointer_functor0</name>
+ <anchorfile>classsigc_1_1pointer__functor0.html</anchorfile>
+ <anchor>a9ae3efd5c13c738db815f619499004d7</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1pointer__functor0.html</anchorfile>
+ <anchor>a56db821303c19ec3345679d80d6ef96e</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1pointer__functor0.html</anchorfile>
+ <anchor>af998b64dac7b3c7eeb2e9a2856a4213e</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::pointer_functor1</name>
+ <filename>classsigc_1_1pointer__functor1.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1pointer__functor1.html</anchorfile>
+ <anchor>a4080910d23a74b102a123838fa93e90b</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>pointer_functor1</name>
+ <anchorfile>classsigc_1_1pointer__functor1.html</anchorfile>
+ <anchor>a6ce467c0641f8e3e0d91f3b843b07c3f</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>pointer_functor1</name>
+ <anchorfile>classsigc_1_1pointer__functor1.html</anchorfile>
+ <anchor>a8ab0c5b707dc41a821c63769344db2cb</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1pointer__functor1.html</anchorfile>
+ <anchor>a3c978e35c107326078f3e33afcdd1235</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1pointer__functor1.html</anchorfile>
+ <anchor>a864ab55240be5287faf07c341ae9501e</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::pointer_functor2</name>
+ <filename>classsigc_1_1pointer__functor2.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1pointer__functor2.html</anchorfile>
+ <anchor>a297b784eb0cea07b364c854e5dd5f864</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>pointer_functor2</name>
+ <anchorfile>classsigc_1_1pointer__functor2.html</anchorfile>
+ <anchor>a2977aa1d72f5f0fd6c778b60ad791b9c</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>pointer_functor2</name>
+ <anchorfile>classsigc_1_1pointer__functor2.html</anchorfile>
+ <anchor>a428226381ff7bda06044c8fa53d4e27e</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1pointer__functor2.html</anchorfile>
+ <anchor>af3d1d778be1730e170c42c52511d6926</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1pointer__functor2.html</anchorfile>
+ <anchor>a340680ba8ae5ea67eb0afe33d118c82b</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::pointer_functor3</name>
+ <filename>classsigc_1_1pointer__functor3.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1pointer__functor3.html</anchorfile>
+ <anchor>a2a0ed29803c02cc62fcc6497f83f88bf</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>pointer_functor3</name>
+ <anchorfile>classsigc_1_1pointer__functor3.html</anchorfile>
+ <anchor>a1a4909d1444e4456a89eb5852933d1cc</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>pointer_functor3</name>
+ <anchorfile>classsigc_1_1pointer__functor3.html</anchorfile>
+ <anchor>aae48103ba1c48e192a04c9a1b81ae9dc</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1pointer__functor3.html</anchorfile>
+ <anchor>adf560c1e583b2216bba4de3027e3a05e</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1pointer__functor3.html</anchorfile>
+ <anchor>a1ac1e43f2515d64c0da4656cdfac1f44</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::pointer_functor4</name>
+ <filename>classsigc_1_1pointer__functor4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1pointer__functor4.html</anchorfile>
+ <anchor>a787f8ea1c15d7bfab7643081a408401c</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>pointer_functor4</name>
+ <anchorfile>classsigc_1_1pointer__functor4.html</anchorfile>
+ <anchor>ab8e3bf143e71c5ffe8f155ace0f895a8</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>pointer_functor4</name>
+ <anchorfile>classsigc_1_1pointer__functor4.html</anchorfile>
+ <anchor>a30eaeb5f9974bed73d7577b862c2e06b</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1pointer__functor4.html</anchorfile>
+ <anchor>a42875d789a30fb04395dbef76d720989</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1pointer__functor4.html</anchorfile>
+ <anchor>af7079533ac64ac9ba23eab99e5c54269</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::pointer_functor5</name>
+ <filename>classsigc_1_1pointer__functor5.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1pointer__functor5.html</anchorfile>
+ <anchor>a00dcbec8a920ea784e3210743c77855b</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>pointer_functor5</name>
+ <anchorfile>classsigc_1_1pointer__functor5.html</anchorfile>
+ <anchor>aa86bb74ff5e188f8f6497b7e73621cdd</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>pointer_functor5</name>
+ <anchorfile>classsigc_1_1pointer__functor5.html</anchorfile>
+ <anchor>abf1e06db145e4554ec53964ca79171cf</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1pointer__functor5.html</anchorfile>
+ <anchor>aa2f399d3f76e802670c8a08ede82c40c</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1pointer__functor5.html</anchorfile>
+ <anchor>a1c97e4e7e8598e06802b07cb86b32466</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::pointer_functor6</name>
+ <filename>classsigc_1_1pointer__functor6.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1pointer__functor6.html</anchorfile>
+ <anchor>a9fd7af745ebad4d59f67e0f60fb395e0</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>pointer_functor6</name>
+ <anchorfile>classsigc_1_1pointer__functor6.html</anchorfile>
+ <anchor>a26551fa703a65a9a14190c7579a3b77d</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>pointer_functor6</name>
+ <anchorfile>classsigc_1_1pointer__functor6.html</anchorfile>
+ <anchor>ab56acb7713cf87d0b3094adc4ffe7a15</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1pointer__functor6.html</anchorfile>
+ <anchor>ac35109048b7360e1436e2b4e3a53d1cf</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1pointer__functor6.html</anchorfile>
+ <anchor>a69c965009b6c3b65106c731b20e60368</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::pointer_functor7</name>
+ <filename>classsigc_1_1pointer__functor7.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1pointer__functor7.html</anchorfile>
+ <anchor>a41613e64e2b96656b85aa9eefa35aa91</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>pointer_functor7</name>
+ <anchorfile>classsigc_1_1pointer__functor7.html</anchorfile>
+ <anchor>a1268abfa3437c0977517dd4cd0548080</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>pointer_functor7</name>
+ <anchorfile>classsigc_1_1pointer__functor7.html</anchorfile>
+ <anchor>a01a6793cd057cd94bba98db3b34a3e7c</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1pointer__functor7.html</anchorfile>
+ <anchor>a564941861ee4b84b9b61a1f247f0cfa1</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1pointer__functor7.html</anchorfile>
+ <anchor>aa092fb6515cb3496529b253b1a57118b</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::reference_wrapper</name>
+ <filename>structsigc_1_1reference__wrapper.html</filename>
+ <templarg></templarg>
+ <member kind="function">
+ <type></type>
+ <name>reference_wrapper</name>
+ <anchorfile>structsigc_1_1reference__wrapper.html</anchorfile>
+ <anchor>a05dfcad06f2af395c5e2daa9600d455a</anchor>
+ <arglist>(T_type &v)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>operator T_type &</name>
+ <anchorfile>structsigc_1_1reference__wrapper.html</anchorfile>
+ <anchor>ae0b2f512b6a2555b489ed9dd229efc1c</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="variable">
+ <type>T_type &</type>
+ <name>value_</name>
+ <anchorfile>structsigc_1_1reference__wrapper.html</anchorfile>
+ <anchor>acf0463810eeadc10cc3dd2eab900145f</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::retype_functor</name>
+ <filename>structsigc_1_1retype__functor.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::adapts</base>
+ <member kind="typedef">
+ <type>adapts< T_functor >::adaptor_type</type>
+ <name>adaptor_type</name>
+ <anchorfile>structsigc_1_1retype__functor.html</anchorfile>
+ <anchor>ace4a0fc864a6417a7cb36adf011177e0</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>adapts< T_functor >::result_type</type>
+ <name>result_type</name>
+ <anchorfile>structsigc_1_1retype__functor.html</anchorfile>
+ <anchor>a1a594553d0312ca12e1009d179af0dbe</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>retype_functor</name>
+ <anchorfile>structsigc_1_1retype__functor.html</anchorfile>
+ <anchor>a30f35ce3d25b7fd571fbd3ef730de225</anchor>
+ <arglist>(type_trait_take_t< T_functor > _A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1retype__functor.html</anchorfile>
+ <anchor>a841d7fd2ae795ca4decccca8342e231c</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1retype__functor.html</anchorfile>
+ <anchor>abfd54e4b77096f76bb0e880b6b7b81e1</anchor>
+ <arglist>(T_arg1 _A_a1)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1retype__functor.html</anchorfile>
+ <anchor>a6207061ea5a530ca3d37459200ef6864</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1retype__functor.html</anchorfile>
+ <anchor>a07b219886709df138ea695049f446215</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1retype__functor.html</anchorfile>
+ <anchor>a66717878d5c0f2a4cb568c8ff622cb97</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1retype__functor.html</anchorfile>
+ <anchor>ad60e39d45f35161727c4a57040589816</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1retype__functor.html</anchorfile>
+ <anchor>a712ff55237e5e0d68195a6d5010f5b3d</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::type</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1retype__functor.html</anchorfile>
+ <anchor>a7b869ff5f806496f7d99f5ae68823291</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)</arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::retype_return_functor</name>
+ <filename>structsigc_1_1retype__return__functor.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::adapts</base>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>structsigc_1_1retype__return__functor.html</anchorfile>
+ <anchor>aa8421dc266ad653de395e7d01e631fdc</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>retype_return_functor</name>
+ <anchorfile>structsigc_1_1retype__return__functor.html</anchorfile>
+ <anchor>aa9546db86a6d1cfa7224a3a0cbad4827</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>retype_return_functor</name>
+ <anchorfile>structsigc_1_1retype__return__functor.html</anchorfile>
+ <anchor>a9ebfb2a6cfb5125b0705c0adef2cbfb8</anchor>
+ <arglist>(type_trait_take_t< T_functor > _A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1retype__return__functor.html</anchorfile>
+ <anchor>a4cf9725b7ac4fdfeded4ab3f56d61a88</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1retype__return__functor.html</anchorfile>
+ <anchor>aa6beb1654c027400d852e2df0fafb6aa</anchor>
+ <arglist>(T_arg1 _A_a1)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1retype__return__functor.html</anchorfile>
+ <anchor>a1352125cef26032af138aa2a327f8f66</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1retype__return__functor.html</anchorfile>
+ <anchor>a0bcbf84c24c2195626bf4e6a2d1353b1</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1retype__return__functor.html</anchorfile>
+ <anchor>a7e3b161bfa746f69a2af64a00af7cbd2</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1retype__return__functor.html</anchorfile>
+ <anchor>a741b3fd8c423d3e63bdefa810e65ef44</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1retype__return__functor.html</anchorfile>
+ <anchor>ab6c4d0b29bbcbca2e64db8249db54171</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1retype__return__functor.html</anchorfile>
+ <anchor>a68bdb4e6cf7d505f210017ab744603f0</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)</arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::retype_return_functor< void, T_functor ></name>
+ <filename>structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html</filename>
+ <templarg></templarg>
+ <base>sigc::adapts</base>
+ <member kind="typedef">
+ <type>void</type>
+ <name>result_type</name>
+ <anchorfile>structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html</anchorfile>
+ <anchor>a64bccc59fc20fdf0fd80281597d350b2</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>retype_return_functor</name>
+ <anchorfile>structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html</anchorfile>
+ <anchor>a720e802de29a72d1e15626b1719844bc</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>retype_return_functor</name>
+ <anchorfile>structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html</anchorfile>
+ <anchor>acd4789babb601ac5bee163651d89f3c8</anchor>
+ <arglist>(type_trait_take_t< T_functor > _A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html</anchorfile>
+ <anchor>af181f5a8134c5a834e2ad0ed7590fbfe</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html</anchorfile>
+ <anchor>a2ad16a9f8f247e6f7661838fb084ffd0</anchor>
+ <arglist>(T_arg1 _A_a1)</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html</anchorfile>
+ <anchor>abf17761c3eefdb3167a8562f009a8491</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2)</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html</anchorfile>
+ <anchor>adb392f4717b522668eb5236dbaf48e68</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html</anchorfile>
+ <anchor>a2c32e33b12c18d0533d4305ddd98dabe</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html</anchorfile>
+ <anchor>a24d383a5100302678a9a18dc5a138e51</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html</anchorfile>
+ <anchor>af0c3d23d0216aa0631720eb00ca8f7ef</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>operator()</name>
+ <anchorfile>structsigc_1_1retype__return__functor_3_01void_00_01T__functor_01_4.html</anchorfile>
+ <anchor>a73a475fd2fe5e4d9e184ca5092b0ced4</anchor>
+ <arglist>(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal</name>
+ <filename>classsigc_1_1signal.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil ></base>
+ <class kind="class">sigc::signal::accumulated</class>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal.html</anchorfile>
+ <anchor>a50432d1aebfbee5ef17a3f434d0c50bf</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal.html</anchorfile>
+ <anchor>a271b486daa2bf801ed7d019da9aa33a1</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal.html</anchorfile>
+ <anchor>abc17a093db8ae8a0a8333c7f35f64bd6</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal.html</anchorfile>
+ <anchor>adeccc0c1c698e33c1da15c7f667f2a23</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal.html</anchorfile>
+ <anchor>abca2c029617e5b39f2852ee0381e7f9e</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal0</name>
+ <filename>classsigc_1_1signal0.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::signal_base</base>
+ <member kind="typedef">
+ <type>slot_list_type::const_iterator</type>
+ <name>const_iterator</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>ad4f7c62954f5c270e115d9b2a2df15ea</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::const_reverse_iterator</type>
+ <name>const_reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a476f559a69eef5999c99cd6262a9aa2f</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>internal::signal_emit0< T_return, T_accumulator ></type>
+ <name>emitter_type</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>ac7eafdced2d325d6003327b4360bc2dd</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::iterator</type>
+ <name>iterator</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>ad61e875748cf4e1c2a6d89a930ae093e</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>emitter_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>ae291a90c83f8ad1cdcc7c2a4cdd958de</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::reverse_iterator</type>
+ <name>reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a1d9c390974304392ed12ee81543ab997</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list< slot_type ></type>
+ <name>slot_list_type</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>add195c1c738ee8efe10294f21d258b77</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot< T_return()></type>
+ <name>slot_type</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>ae3fc90cec344b6585979e77d2b359287</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal0</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a2fb24e11a8f645e5122646ea2b4a5d2f</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal0</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a7dc687f1afb4088a3d888aa05dbf56d9</anchor>
+ <arglist>(const signal0 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal0</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>ac1b915a86d0b75fd4e90c2a92f7ebc49</anchor>
+ <arglist>(signal0 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a609b1e0770f47c9081a3de56b65314d2</anchor>
+ <arglist>(const slot_type &slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a9b78954271b6dba5e926bd960f3e7905</anchor>
+ <arglist>(slot_type &&slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a655829125186645bcbc61db8252134a8</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit_reverse</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>abdae39f9a7abd6133c03d65224c227d6</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor0< result_type, signal0 ></type>
+ <name>make_slot</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a3295536428e5e0d6478ac10e2daff736</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a2dd3042c0681542ed6f2de5840f713a1</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>signal0 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a4e8311eac2fd7f8ecd10bff8225ed9e3</anchor>
+ <arglist>(const signal0 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal0 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a693aa3743236012416349bfac56d31b6</anchor>
+ <arglist>(signal0 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a5576113ddfd6b92a96f86072262307f9</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a73523d71edd7fb4294324e9561db6f3c</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal1</name>
+ <filename>classsigc_1_1signal1.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::signal_base</base>
+ <member kind="typedef">
+ <type>slot_list_type::const_iterator</type>
+ <name>const_iterator</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>af1e262b35c9574e65b2607cdfcaad707</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::const_reverse_iterator</type>
+ <name>const_reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>aeb327519f808dfec9a723511ef82caa3</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>internal::signal_emit1< T_return, T_arg1, T_accumulator ></type>
+ <name>emitter_type</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a63c6e2b55c8c3af083402bb7f5a66593</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::iterator</type>
+ <name>iterator</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>ab61e2d1fcaf903dffbb26b01800907fb</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>emitter_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>adcdcfa50d60e1832ce038a4a5554fce1</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::reverse_iterator</type>
+ <name>reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>ab0443049aa736d88770d0f534600b2bc</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list< slot_type ></type>
+ <name>slot_list_type</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a5fadeb350140d6aaf560b217e7e7c4b4</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot< T_return(T_arg1)></type>
+ <name>slot_type</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a310736e1415c2cf4578892ffff35915c</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal1</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>aba62d8d0b9591bcfd728f8ae8a22d600</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal1</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>ab3378dd754ffddb4760f2a3afb271dbe</anchor>
+ <arglist>(const signal1 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal1</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a85ec968e0b25ee9285f297da5416b2a4</anchor>
+ <arglist>(signal1 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>aac2ade0896bd4a982777d5dd6ac75888</anchor>
+ <arglist>(const slot_type &slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>ac69d2681c586b310d8c056a319bb65fe</anchor>
+ <arglist>(slot_type &&slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>affe595f8b70b4f43a21be7192c0cba42</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1) const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit_reverse</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a449fc940ae822c4b6ea9282b9b292015</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1) const</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor1< result_type, signal1, type_trait_take_t< T_arg1 > ></type>
+ <name>make_slot</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a87513117263fd39d5a5a86e0fb8b2a78</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a828907c11f5c18d9522e5d5139484620</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1) const</arglist>
+ </member>
+ <member kind="function">
+ <type>signal1 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a29cd06bf91f96f11c5f29237b8afbb71</anchor>
+ <arglist>(const signal1 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal1 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>ab817711d4bc93402d15e87b89a09c364</anchor>
+ <arglist>(signal1 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a7653b68e6a3b8445de91f89060bf2600</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a7777660b21fef2a6941c7dff23964604</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal2</name>
+ <filename>classsigc_1_1signal2.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::signal_base</base>
+ <member kind="typedef">
+ <type>slot_list_type::const_iterator</type>
+ <name>const_iterator</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>ad507bc5ea29adb2305f8fa91acbd30ee</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::const_reverse_iterator</type>
+ <name>const_reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>aacb8fe57ffe01dea5c5fb5af44634287</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>internal::signal_emit2< T_return, T_arg1, T_arg2, T_accumulator ></type>
+ <name>emitter_type</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>a01379d580d21de8bc8d0d2d62e6324ea</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::iterator</type>
+ <name>iterator</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>a658ba1c6468882c9b1d480be2bbaf55e</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>emitter_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>a55151695417c33540357ff524bfe2665</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::reverse_iterator</type>
+ <name>reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>a6710759bdeb8e626fc09d8c448e6613f</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list< slot_type ></type>
+ <name>slot_list_type</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>af31262f54dfb2a97540de9c4a1fc5726</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot< T_return(T_arg1, T_arg2)></type>
+ <name>slot_type</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>af7797ae10e76307f8d230588e760f119</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal2</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>a47aba9b19bc2bef0be7183022567e3ea</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal2</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>aa634515507f2ea4a35584e12e2dc92e7</anchor>
+ <arglist>(const signal2 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal2</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>a20c59f06175d4c48394c65035d2c3376</anchor>
+ <arglist>(signal2 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>aa686af4f961b098a23d4f7276437c2b0</anchor>
+ <arglist>(const slot_type &slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>ab89b1876c69ea40954b0af37e75a21b4</anchor>
+ <arglist>(slot_type &&slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>afd12e2a266a6399cc32e888d6f5e6f2f</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit_reverse</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>ad2d5f3169ba147de8d43fde9e93bac98</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor2< result_type, signal2, type_trait_take_t< T_arg1 >, type_trait_take_t< T_arg2 > ></type>
+ <name>make_slot</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>a844d15c61c83933575e7953b29365efa</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>ac8b73c0624273b8dae819255961ea6a3</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</arglist>
+ </member>
+ <member kind="function">
+ <type>signal2 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>abeb05d9a2b40882bad753fccad6522be</anchor>
+ <arglist>(const signal2 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal2 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>a5d3f71fb9ee8754c4640fb5bfb954151</anchor>
+ <arglist>(signal2 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>ac28b0205aa1e60cc5ce062d4d8545323</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>aa6be4804147afd56657abf5b4cf8ce3d</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal3</name>
+ <filename>classsigc_1_1signal3.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::signal_base</base>
+ <member kind="typedef">
+ <type>slot_list_type::const_iterator</type>
+ <name>const_iterator</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a60e1ef95f82cd8981d61576d1e3f8e94</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::const_reverse_iterator</type>
+ <name>const_reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a4ba3eb58c4c5ac2c25f49c48fd0af264</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>internal::signal_emit3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></type>
+ <name>emitter_type</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>adf54ec96c5fb78d4c8b7fc032a1937ad</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::iterator</type>
+ <name>iterator</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a8029a48126a2018947a2b6680ddabe6b</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>emitter_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a57c79755fc4c4b04196a9bf6742a0cc6</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::reverse_iterator</type>
+ <name>reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>acc453f0d5fc7f277494b2d6e737f6f68</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list< slot_type ></type>
+ <name>slot_list_type</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a3bc0616e7ac933e702a889a2a84e92d4</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot< T_return(T_arg1, T_arg2, T_arg3)></type>
+ <name>slot_type</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>afe37478128b40fb4efedcd3c0eb05b6b</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal3</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a52731959f272612fd6abfe8850c5c8cf</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal3</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>afe2c4320927b403b011a2538317e6c70</anchor>
+ <arglist>(const signal3 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal3</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>acd69c2a1d993f0b8993f82998f76020d</anchor>
+ <arglist>(signal3 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a3eae0b3796b2736be847f33a5124aacd</anchor>
+ <arglist>(const slot_type &slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>ad71389c6d6ea60e745897579b3344d00</anchor>
+ <arglist>(slot_type &&slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a8592e22e3780f2cdf19a568a8a116bbb</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit_reverse</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a97ff4f22c97920a81e3f27aa5d39ba99</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor3< result_type, signal3, type_trait_take_t< T_arg1 >, type_trait_take_t< T_arg2 >, type_trait_take_t< T_arg3 > ></type>
+ <name>make_slot</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a332be8eb0ee22c11a2e1d140ca1bc2df</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>aa7ae5338d6a883a28c61ff202e43547f</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</arglist>
+ </member>
+ <member kind="function">
+ <type>signal3 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a0c398a25051e920bc4338f35b4bf7df6</anchor>
+ <arglist>(const signal3 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal3 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>abafd9fe17f2b9b18e25eb0293e9e8bfd</anchor>
+ <arglist>(signal3 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>ab9606b708078956a758b81503f956bee</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a742eb282312187bf8ee6992df1114781</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal4</name>
+ <filename>classsigc_1_1signal4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::signal_base</base>
+ <member kind="typedef">
+ <type>slot_list_type::const_iterator</type>
+ <name>const_iterator</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a3d2626edc726047c04c8fe5b9824b958</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::const_reverse_iterator</type>
+ <name>const_reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a555ce030884fdf2bde788b75db01bedf</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>internal::signal_emit4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></type>
+ <name>emitter_type</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>acf3d1e6d6487c0ecc13ed3eab949eec7</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::iterator</type>
+ <name>iterator</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a31e8354263a3097bba9c63b8494143f0</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>emitter_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>af32418ba14001a63d28af08abb7407f0</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::reverse_iterator</type>
+ <name>reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a1395da7d3283b0166af135193a4047c8</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list< slot_type ></type>
+ <name>slot_list_type</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a0ad0f56a43825c6d77d36dd2f06ef828</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot< T_return(T_arg1, T_arg2, T_arg3, T_arg4)></type>
+ <name>slot_type</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>aa93452fe80399184444d094786be851c</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal4</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a2d469f516a9edac2b20d7f6cf46e821a</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal4</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a2d29b39c12c6c014ed7166190e9c8e22</anchor>
+ <arglist>(const signal4 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal4</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a2197974bac2b5e8e7b1c417580686e9e</anchor>
+ <arglist>(signal4 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a5fdb6df3cf74f5c96fb6319eef4d0a39</anchor>
+ <arglist>(const slot_type &slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a5c8d2d9c91a134650a52631d49ecdaac</anchor>
+ <arglist>(slot_type &&slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>aa7774ba75b5e2391a6fe2841f8b3b0ef</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit_reverse</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a0aaf27875cdb8a0ae381372d98871ae1</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor4< result_type, signal4, type_trait_take_t< T_arg1 >, type_trait_take_t< T_arg2 >, type_trait_take_t< T_arg3 >, type_trait_take_t< T_arg4 > ></type>
+ <name>make_slot</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>aebcf1389e689b8d43ff739df118482bc</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a8523a4d47c3a6469fcc50da9977afdb8</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</arglist>
+ </member>
+ <member kind="function">
+ <type>signal4 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a05908db9c09a9c513529cd8b2106f913</anchor>
+ <arglist>(const signal4 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal4 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>ab21da01af7c724bf0cf9df35ee9a70c1</anchor>
+ <arglist>(signal4 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>ae490f1a6802c40a4c3b12e1580520c88</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a35f2cebe3804d3e04d3253b7cc8d2a72</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal5</name>
+ <filename>classsigc_1_1signal5.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::signal_base</base>
+ <member kind="typedef">
+ <type>slot_list_type::const_iterator</type>
+ <name>const_iterator</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a17e79eed46f178a12d2751eddcf85290</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::const_reverse_iterator</type>
+ <name>const_reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>ad5ba46907fe236e0cff806888696d569</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>internal::signal_emit5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></type>
+ <name>emitter_type</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a7d77e5fa748b024842bf92e28cf0f4ab</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::iterator</type>
+ <name>iterator</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>acee689b441305fcee098345729fc28f3</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>emitter_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>aceb959897dcf8e3c7209c283d4848b94</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::reverse_iterator</type>
+ <name>reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>ab684cb9920d0f7949f28c03d50b58275</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list< slot_type ></type>
+ <name>slot_list_type</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a4c79ab227fc3b31b990e925636f7788e</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)></type>
+ <name>slot_type</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>ae73737aad5d854c6466e8b13e7963b9e</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal5</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>af717d1a6fd8612da84dce33fe6640b7a</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal5</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a7885861b9cdbacbe2d58a13cd96ec265</anchor>
+ <arglist>(const signal5 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal5</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>af39141aeec9dc870dd28926202493de4</anchor>
+ <arglist>(signal5 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a057789cc27a920700e240f8f3d78dd65</anchor>
+ <arglist>(const slot_type &slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a05cfed3d3e29158424bc810168d78153</anchor>
+ <arglist>(slot_type &&slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a8772fef879632c4ff45e82b4b00b0157</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit_reverse</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>aa6d2e202263e3879f0d3949612d7fcdf</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor5< result_type, signal5, type_trait_take_t< T_arg1 >, type_trait_take_t< T_arg2 >, type_trait_take_t< T_arg3 >, type_trait_take_t< T_arg4 >, type_trait_take_t< T_arg5 > ></type>
+ <name>make_slot</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a7b01481c87d4ec9c03095e76cb502c24</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a7a5bb7b92f49e99354caf50bfef16907</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</arglist>
+ </member>
+ <member kind="function">
+ <type>signal5 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a2c3d9a6d8b499da389672f44f8044ce6</anchor>
+ <arglist>(const signal5 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal5 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a5c652f8e549a2c555b79db8e8a05f407</anchor>
+ <arglist>(signal5 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>ad6a4ae2a214d8710be6e36bb425587fc</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a32af276c9c56abbb0386f54262b40be5</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal6</name>
+ <filename>classsigc_1_1signal6.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::signal_base</base>
+ <member kind="typedef">
+ <type>slot_list_type::const_iterator</type>
+ <name>const_iterator</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>ac88a9c4e9bab5ad04c66d3f5d3978f0f</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::const_reverse_iterator</type>
+ <name>const_reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>aff490e7f75a83aa2f324a859f9071a79</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>internal::signal_emit6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></type>
+ <name>emitter_type</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>acdd2683223e4701f58350152f32f4488</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::iterator</type>
+ <name>iterator</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a1acee11287974cdac1bc63c856e5331d</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>emitter_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a56f1acca230e676dae665d41a10acc8f</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::reverse_iterator</type>
+ <name>reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a79b741b3f0def8f52fc185ad50b60673</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list< slot_type ></type>
+ <name>slot_list_type</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a0e4fea9bd1ed35f9d60bbc26c4fae007</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)></type>
+ <name>slot_type</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>ac62cdf4db7dcd5e30975e51e978f03db</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal6</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>af7f529bbd9cf26d468ed18426b9b51ea</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal6</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a0244dde296bd892c590c86ced5281e3b</anchor>
+ <arglist>(const signal6 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal6</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>ab717ce413bda79e1de41944d0675a8ca</anchor>
+ <arglist>(signal6 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a66c302607cf4fb74f5d3352f9c394c9b</anchor>
+ <arglist>(const slot_type &slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a1754aa5a8959da0bb55e42864a8365af</anchor>
+ <arglist>(slot_type &&slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a6361a9230323e7c7e86e2c9e6c8fe21b</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit_reverse</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a2e8b355902f0646fb34b52b495123167</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor6< result_type, signal6, type_trait_take_t< T_arg1 >, type_trait_take_t< T_arg2 >, type_trait_take_t< T_arg3 >, type_trait_take_t< T_arg4 >, type_trait_take_t< T_arg5 >, type_trait_take_t< T_arg6 > ></type>
+ <name>make_slot</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a97ae4180e80ac60b564fec58d1732317</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>affec011fd6e9605f10e50fdd4db424d8</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</arglist>
+ </member>
+ <member kind="function">
+ <type>signal6 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>ad7a4ab249b17bffccbfe441aa1420dd9</anchor>
+ <arglist>(const signal6 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal6 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a012b9abce888e420e1b5b3f29aa98900</anchor>
+ <arglist>(signal6 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>af44115a7bfa4586fc5312259a1df9567</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>ac66109f683ae86898ae10109a80b28a4</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal7</name>
+ <filename>classsigc_1_1signal7.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::signal_base</base>
+ <member kind="typedef">
+ <type>slot_list_type::const_iterator</type>
+ <name>const_iterator</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a6eef6225eba66a86dd32c3f3b79845f7</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::const_reverse_iterator</type>
+ <name>const_reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>ad1ba32ad7dae0c05a4012ada78077505</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>internal::signal_emit7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></type>
+ <name>emitter_type</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a7fa856e67a31c86538db7c289a6870e3</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::iterator</type>
+ <name>iterator</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>abc62e52cc684f917577a2fe3cd914d4a</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>emitter_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a5a75d73a254cf91a0f3ad1cd3545e29f</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::reverse_iterator</type>
+ <name>reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a59c9c9fee7a98528839df592241351a9</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list< slot_type ></type>
+ <name>slot_list_type</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a79686c2174ab01dc23394953955ff003</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)></type>
+ <name>slot_type</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a72ee8c51eea3d1ba99eb9b512dfccd81</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal7</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>ab6d54db53a164fb459fcb342d4b45ff0</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal7</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a12d6e064d0a5c2a8c09d60a64184a823</anchor>
+ <arglist>(const signal7 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal7</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a5a5893dd4f97d77b7945819f5ada2aee</anchor>
+ <arglist>(signal7 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>adc55ac9b0f935fd87a67904022e03cb2</anchor>
+ <arglist>(const slot_type &slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a5aed4bdb8d85c3d854f01410d2d9d3a4</anchor>
+ <arglist>(slot_type &&slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>aead3b0e97ed0bd95f870b1956bff83c2</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit_reverse</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a192581feb2dbcfc9c56692e72e91e9a8</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor7< result_type, signal7, type_trait_take_t< T_arg1 >, type_trait_take_t< T_arg2 >, type_trait_take_t< T_arg3 >, type_trait_take_t< T_arg4 >, type_trait_take_t< T_arg5 >, type_trait_take_t< T_arg6 >, type_trait_take_t< T_arg7 > ></type>
+ <name>make_slot</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a3f468c8b6cc55d675c75d0184bd8e38a</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>ac6fd43215c8f19082402387359330071</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</arglist>
+ </member>
+ <member kind="function">
+ <type>signal7 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>af8a93a4c8fb0b78fa6578e7dc95f5751</anchor>
+ <arglist>(const signal7 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal7 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>ac06938f5cb6ff60a1bd5eaa32c990eea</anchor>
+ <arglist>(signal7 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a68153d9079b4881352113079cd6216f7</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a42509108239296e424844df2cd330aca</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal::accumulated</name>
+ <filename>classsigc_1_1signal_1_1accumulated.html</filename>
+ <templarg></templarg>
+ <base>signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></base>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_1_1accumulated.html</anchorfile>
+ <anchor>a46bed3515606e0a5807f08e239891ca0</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_1_1accumulated.html</anchorfile>
+ <anchor>a032428476a190d9dea6313f70e5b8a10</anchor>
+ <arglist>(const accumulated &src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return()></name>
+ <filename>classsigc_1_1signal_3_01T__return_07_08_4.html</filename>
+ <templarg></templarg>
+ <base>signal0< T_return, nil ></base>
+ <class kind="class">sigc::signal< T_return()>::accumulated</class>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07_08_4.html</anchorfile>
+ <anchor>aefdfdd54adc65612b58929298274453c</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07_08_4.html</anchorfile>
+ <anchor>aba571147db7b805fad8da3c0c82fea0b</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07_08_4.html</anchorfile>
+ <anchor>a2656448f8eb3cf4d9043009f56b08104</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07_08_4.html</anchorfile>
+ <anchor>acbc101f4d7b4e460929593bac336957f</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07_08_4.html</anchorfile>
+ <anchor>a8dd6b8bd581d87858007484d62347484</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return()>::accumulated</name>
+ <filename>classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html</filename>
+ <templarg></templarg>
+ <base>signal0< T_return, T_accumulator ></base>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html</anchorfile>
+ <anchor>a601feadb67ac4aaa7af709af51f654ca</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07_08_4_1_1accumulated.html</anchorfile>
+ <anchor>a219dd919cd64e95ad89c5a501b3abcf6</anchor>
+ <arglist>(const accumulated &src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return(T_arg1)></name>
+ <filename>classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>signal1< T_return, T_arg1, nil ></base>
+ <class kind="class">sigc::signal< T_return(T_arg1)>::accumulated</class>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html</anchorfile>
+ <anchor>a2e6e6d55741d1ef7e4ef3cf1a385ccf1</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html</anchorfile>
+ <anchor>a41a5c99993530756404583e4fbc748ba</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html</anchorfile>
+ <anchor>acc30f0949e699fbff85d341162298761</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html</anchorfile>
+ <anchor>a20f539ef645cba235c03d8d13f221ae5</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_08_4.html</anchorfile>
+ <anchor>a1014db39eed6f085ab79116510005e4c</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return(T_arg1)>::accumulated</name>
+ <filename>classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html</filename>
+ <templarg></templarg>
+ <base>signal1< T_return, T_arg1, T_accumulator ></base>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html</anchorfile>
+ <anchor>a31b87e65e2e6be201c18ff7c7c3e87e9</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_08_4_1_1accumulated.html</anchorfile>
+ <anchor>abbb5481dc26b9efce3b8604eb0f6ea27</anchor>
+ <arglist>(const accumulated &src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return(T_arg1, T_arg2)></name>
+ <filename>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>signal2< T_return, T_arg1, T_arg2, nil ></base>
+ <class kind="class">sigc::signal< T_return(T_arg1, T_arg2)>::accumulated</class>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html</anchorfile>
+ <anchor>a9d8fa2e7dd971a359c53c5ed19310f00</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html</anchorfile>
+ <anchor>a13d95a6b3058ddbd0f55fd00953cdee5</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html</anchorfile>
+ <anchor>acc41707d3187fe1ac6bb9180f82428a7</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html</anchorfile>
+ <anchor>abdcf63e52e05fd88654a7e688abd57b1</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4.html</anchorfile>
+ <anchor>a925adc69603e7caab05920baf7f80faf</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return(T_arg1, T_arg2)>::accumulated</name>
+ <filename>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html</filename>
+ <templarg></templarg>
+ <base>signal2< T_return, T_arg1, T_arg2, T_accumulator ></base>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html</anchorfile>
+ <anchor>abf5d54ba4c8e7f2792be010df45df59b</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_08_4_1_1accumulated.html</anchorfile>
+ <anchor>af6082d36c41f676b54f271f31ca781b6</anchor>
+ <arglist>(const accumulated &src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return(T_arg1, T_arg2, T_arg3)></name>
+ <filename>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></base>
+ <class kind="class">sigc::signal< T_return(T_arg1, T_arg2, T_arg3)>::accumulated</class>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html</anchorfile>
+ <anchor>a27d493742451c292a6c001b9353c08d9</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html</anchorfile>
+ <anchor>a51bd913df6a849d6dd720e8c19532149</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html</anchorfile>
+ <anchor>ac22b59e41db40b6cbe6ac4b71d048170</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html</anchorfile>
+ <anchor>a43ee800d35a162d99893f6a55f5a7c72</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4.html</anchorfile>
+ <anchor>aee5b61e3b98fe989e78f96d2117d74d1</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return(T_arg1, T_arg2, T_arg3)>::accumulated</name>
+ <filename>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html</filename>
+ <templarg></templarg>
+ <base>signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></base>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html</anchorfile>
+ <anchor>a096e447ba082bebd28601309d595807c</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_08_4_1_1accumulated.html</anchorfile>
+ <anchor>ad47d6448e3137d45649656d23b19f89a</anchor>
+ <arglist>(const accumulated &src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)></name>
+ <filename>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></base>
+ <class kind="class">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::accumulated</class>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html</anchorfile>
+ <anchor>a1569f4348e140681f696a49028309042</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html</anchorfile>
+ <anchor>a435444e5772da8ddb74edb7f901f3ae6</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html</anchorfile>
+ <anchor>a8d26e7db0ca474d71736c778e0264f4c</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html</anchorfile>
+ <anchor>a838a70902714d4cb065ea1bf22e0f376</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4.html</anchorfile>
+ <anchor>abeda698e53b2b9b3bd9e5aa91f02abfd</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)>::accumulated</name>
+ <filename>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html</filename>
+ <templarg></templarg>
+ <base>signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></base>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html</anchorfile>
+ <anchor>acd7fd012dcc073e9a6770af949517040</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_08_4_1_1accumulated.html</anchorfile>
+ <anchor>a3197013a55f3afc0fb9451b033c3fe47</anchor>
+ <arglist>(const accumulated &src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)></name>
+ <filename>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></base>
+ <class kind="class">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::accumulated</class>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html</anchorfile>
+ <anchor>a7006442d66ee8f812ffdff15cd5694a3</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html</anchorfile>
+ <anchor>a7d61f31c6577339602b629bff20f0248</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html</anchorfile>
+ <anchor>a016fcefe1eb805926dafad10f970f826</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html</anchorfile>
+ <anchor>ac3fd7b8ac2caf93330629a3caa000d57</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4.html</anchorfile>
+ <anchor>a95b7d55776c477cae58859f01a043d6e</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>::accumulated</name>
+ <filename>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html</filename>
+ <templarg></templarg>
+ <base>signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></base>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html</anchorfile>
+ <anchor>a77a966e973f4ab159f0dbb92737dd02e</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_08_4_1_1accumulated.html</anchorfile>
+ <anchor>a3b820b8e12b845648ff1eeff72bf97fa</anchor>
+ <arglist>(const accumulated &src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)></name>
+ <filename>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></base>
+ <class kind="class">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::accumulated</class>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html</anchorfile>
+ <anchor>a6ec07b9037eeeab8094beb440d80407b</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html</anchorfile>
+ <anchor>a975a2a33c137e6b662a31933d80563d6</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html</anchorfile>
+ <anchor>a16f865ba75270a1808ed8f3a37e53a48</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html</anchorfile>
+ <anchor>ad93fa9a04fa76e3133adb4361981c5cd</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_08_4.html</anchorfile>
+ <anchor>a249b8264efb4167bf468a6b4c01fe6b5</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>::accumulated</name>
+ <filename>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html</filename>
+ <templarg></templarg>
+ <base>signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></base>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html</anchorfile>
+ <anchor>a3daa5943f5b629a17a547b75743b8829</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_dace8c5b03b250e13cd615dbc3de0ac4.html</anchorfile>
+ <anchor>afe1cea16b0f0296ff874a2793cc51b53</anchor>
+ <arglist>(const accumulated &src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)></name>
+ <filename>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil ></base>
+ <class kind="class">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::accumulated</class>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html</anchorfile>
+ <anchor>ac3cad4e400bacfc4a539cb7a31cd0e01</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html</anchorfile>
+ <anchor>a9b9928bf9b40cae47599be1f4f7f85dc</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html</anchorfile>
+ <anchor>a5595334118f67137ded1af1720743da8</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html</anchorfile>
+ <anchor>a8fe96aaacf6a2d0780887623a6f2b15a</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01T__arg7_08_4.html</anchorfile>
+ <anchor>aaa92f0fe77bca0af86a3a0ddd77bc96b</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::accumulated</name>
+ <filename>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html</filename>
+ <templarg></templarg>
+ <base>signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></base>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html</anchorfile>
+ <anchor>a33552c46e4db86b98bea128fd32d2c08</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_07T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_e94644748df11174db4187c0801a1d95.html</anchorfile>
+ <anchor>afc104f4e3d7a445cf4f7989c52f1d93c</anchor>
+ <arglist>(const accumulated &src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil ></name>
+ <filename>classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</filename>
+ <templarg></templarg>
+ <base>signal0< T_return, nil ></base>
+ <class kind="class">sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil >::accumulated</class>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a69bd320a61ade13046ae3ed20498ab83</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a3dcbc7a6481f46f08a366e489876a7a0</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a59107d243fe3408d64e4e963d5023dcb</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a9603080b1a0c76e32eb6859594c59665</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a08ac3766c65bb61177b49a62667a5a53</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil >::accumulated</name>
+ <filename>classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html</filename>
+ <templarg></templarg>
+ <base>signal0< T_return, T_accumulator ></base>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html</anchorfile>
+ <anchor>a54763bd7352a9c84b5e5956b4f65c914</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html</anchorfile>
+ <anchor>a1cea5890a6ac54f475ae28062c99e4f4</anchor>
+ <arglist>(const accumulated &src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></name>
+ <filename>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>signal1< T_return, T_arg1, nil ></base>
+ <class kind="class">sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::accumulated</class>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a7561df6caf1f508eff71f035db8260c1</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>ae55caf393287987076a093a17cd2a272</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>aee2249d4e36771d4f2d5f6c8848a95ce</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a418026bd364a6b5510f0227f497b9473</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>ac10afd98d20258707f8748f4af3063d9</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil >::accumulated</name>
+ <filename>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html</filename>
+ <templarg></templarg>
+ <base>signal1< T_return, T_arg1, T_accumulator ></base>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html</anchorfile>
+ <anchor>a772b7939dc0552087c6b52a98d97eab8</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html</anchorfile>
+ <anchor>a94b30a9ffefefc43cb79b4f30ad65237</anchor>
+ <arglist>(const accumulated &src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></name>
+ <filename>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>signal2< T_return, T_arg1, T_arg2, nil ></base>
+ <class kind="class">sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::accumulated</class>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a3ad9be2894fd3f78bfde9488207ff502</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a199611dacb9e03614c9203ad27597667</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>ae7f76745ea92595cdd179725425487ea</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a3baee6b97500078ea6297959e1f9ca9c</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>ab610351f5cdf9f332d9a1003a0481ab3</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil >::accumulated</name>
+ <filename>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html</filename>
+ <templarg></templarg>
+ <base>signal2< T_return, T_arg1, T_arg2, T_accumulator ></base>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html</anchorfile>
+ <anchor>a83f917545362d71b7d08fee23e619eaf</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4_1_1accumulated.html</anchorfile>
+ <anchor>aa462577f7f52f54b2bf2c87cbb7aa9bc</anchor>
+ <arglist>(const accumulated &src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></name>
+ <filename>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></base>
+ <class kind="class">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::accumulated</class>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a3866d625025ecae063d59e81f86ec836</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a80e31f482db26fc380264b7dea1041d7</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a84d26ae312afec80b6a921894a52e9a8</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a706478aa21230e1b6ff4347f87efb0dc</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a8a0166f439840b854ab3253fa831bb03</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil >::accumulated</name>
+ <filename>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html</filename>
+ <templarg></templarg>
+ <base>signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></base>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html</anchorfile>
+ <anchor>a86aae36f669ce2f9d7f1f0ac9a696f6c</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01852c349c390cefa04662a850d84c0a94.html</anchorfile>
+ <anchor>ab20d2ddd7330aa974d61ddec753413b6</anchor>
+ <arglist>(const accumulated &src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></name>
+ <filename>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></base>
+ <class kind="class">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::accumulated</class>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a76731fb4092ef8d9b459c8c32c5433dc</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a299bbe1b511723c6c854e516aaf0a926</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a51f9443b48b006a65114bdd18d13cd4b</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a84ee7d648bf622ec496127ceec819946</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a7e84970efac0339e7ebaaa46540ef0cc</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil >::accumulated</name>
+ <filename>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html</filename>
+ <templarg></templarg>
+ <base>signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></base>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html</anchorfile>
+ <anchor>a994494b04443cda13eef81e13321db83</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_0d729ce48b1328d982e0ee754652fed04.html</anchorfile>
+ <anchor>a2d21852efcef1d59cc96c8c873e6ce37</anchor>
+ <arglist>(const accumulated &src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></name>
+ <filename>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></base>
+ <class kind="class">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::accumulated</class>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a5e64ba037f3567ab5dbb49811a447b2c</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a2f45d321526546618c56c1d5400507d2</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a3447b5d32b839fa22ac7845ea448d2b4</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a4d6e1453a0b4284cc19996e36cff5eef</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a05a22fca63088154ba5c15b221e30760</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil >::accumulated</name>
+ <filename>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html</filename>
+ <templarg></templarg>
+ <base>signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></base>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html</anchorfile>
+ <anchor>a0b18943e223f1ae150ee5541673a2e29</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arcf6cb51783c363bfae7c4a91d9685109.html</anchorfile>
+ <anchor>a3e41ce87d15bc90960abd857ca80aed9</anchor>
+ <arglist>(const accumulated &src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></name>
+ <filename>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></base>
+ <class kind="class">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::accumulated</class>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html</anchorfile>
+ <anchor>a1dd1e779ef29d6df2b570847c4f2819e</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html</anchorfile>
+ <anchor>aa070e4d37a8a06ef9fc02256d236472c</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html</anchorfile>
+ <anchor>a09609c04d7601601c9726aef1c74ecc7</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html</anchorfile>
+ <anchor>ace9ebd1d47d825a1ee18ae0b2c639ab1</anchor>
+ <arglist>(const signal &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html</anchorfile>
+ <anchor>a6cbe2b81b53c97bc39c26bbedcb070f1</anchor>
+ <arglist>(signal &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil >::accumulated</name>
+ <filename>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html</filename>
+ <templarg></templarg>
+ <base>signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></base>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html</anchorfile>
+ <anchor>a0f2cc39e9f222a296072f8c05ad98796</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>accumulated</name>
+ <anchorfile>classsigc_1_1signal_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__are33def4d0c1a12dcbfd220489302db67.html</anchorfile>
+ <anchor>a239f7a4fefc7cb2cc6c4fb6c9c332d2f</anchor>
+ <arglist>(const accumulated &src)</arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::signal_base</name>
+ <filename>structsigc_1_1signal__base.html</filename>
+ <base>sigc::trackable</base>
+ <member kind="typedef">
+ <type>std::size_t</type>
+ <name>size_type</name>
+ <anchorfile>structsigc_1_1signal__base.html</anchorfile>
+ <anchor>aa60e22abd088b6cde2dd50fb3f228aa4</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal_base</name>
+ <anchorfile>structsigc_1_1signal__base.html</anchorfile>
+ <anchor>aff65198ddcb4fbccb644ff853e663e0e</anchor>
+ <arglist>() noexcept</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal_base</name>
+ <anchorfile>structsigc_1_1signal__base.html</anchorfile>
+ <anchor>a761e95b8c7b460664d3338ed3eb39543</anchor>
+ <arglist>(const signal_base &src) noexcept</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal_base</name>
+ <anchorfile>structsigc_1_1signal__base.html</anchorfile>
+ <anchor>a9f8570c89cd5c0b35613570a5ea80154</anchor>
+ <arglist>(signal_base &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>~signal_base</name>
+ <anchorfile>structsigc_1_1signal__base.html</anchorfile>
+ <anchor>afa2e5807537c989b430015e5ae05a357</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>block</name>
+ <anchorfile>structsigc_1_1signal__base.html</anchorfile>
+ <anchor>a52fda4806ec9dbc02baa95ce70c13fb0</anchor>
+ <arglist>(bool should_block=true) noexcept</arglist>
+ </member>
+ <member kind="function">
+ <type>bool</type>
+ <name>blocked</name>
+ <anchorfile>structsigc_1_1signal__base.html</anchorfile>
+ <anchor>a228da4dd1eac6905dafbc5697086e503</anchor>
+ <arglist>() const noexcept</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>clear</name>
+ <anchorfile>structsigc_1_1signal__base.html</anchorfile>
+ <anchor>a17597d66e680d222248c523985f0afd6</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>bool</type>
+ <name>empty</name>
+ <anchorfile>structsigc_1_1signal__base.html</anchorfile>
+ <anchor>a24e7fc4e07ac19cebafe8e3bd71bfe94</anchor>
+ <arglist>() const noexcept</arglist>
+ </member>
+ <member kind="function">
+ <type>signal_base &</type>
+ <name>operator=</name>
+ <anchorfile>structsigc_1_1signal__base.html</anchorfile>
+ <anchor>a90b36a7b33e107ce0af0de895e0df286</anchor>
+ <arglist>(const signal_base &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal_base &</type>
+ <name>operator=</name>
+ <anchorfile>structsigc_1_1signal__base.html</anchorfile>
+ <anchor>a277a34edf44207fb4784807eac5872c6</anchor>
+ <arglist>(signal_base &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>size_type</type>
+ <name>size</name>
+ <anchorfile>structsigc_1_1signal__base.html</anchorfile>
+ <anchor>a0725416f747d6db3c57fa318a9f887a8</anchor>
+ <arglist>() const noexcept</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>unblock</name>
+ <anchorfile>structsigc_1_1signal__base.html</anchorfile>
+ <anchor>aebb7ac69ea745cd60c0505f8d553d27f</anchor>
+ <arglist>() noexcept</arglist>
+ </member>
+ <member kind="typedef" protection="protected">
+ <type>internal::signal_impl::iterator_type</type>
+ <name>iterator_type</name>
+ <anchorfile>structsigc_1_1signal__base.html</anchorfile>
+ <anchor>a328b132e5dfb99dbc3aae1e5c3bb0981</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function" protection="protected">
+ <type>iterator_type</type>
+ <name>connect</name>
+ <anchorfile>structsigc_1_1signal__base.html</anchorfile>
+ <anchor>a5c89a76a27d69c512f554b841b1bd08a</anchor>
+ <arglist>(const slot_base &slot_)</arglist>
+ </member>
+ <member kind="function" protection="protected">
+ <type>iterator_type</type>
+ <name>connect</name>
+ <anchorfile>structsigc_1_1signal__base.html</anchorfile>
+ <anchor>a50eab6d37728bbbf3beb21d684a72e6c</anchor>
+ <arglist>(slot_base &&slot_)</arglist>
+ </member>
+ <member kind="function" protection="protected">
+ <type>iterator_type</type>
+ <name>erase</name>
+ <anchorfile>structsigc_1_1signal__base.html</anchorfile>
+ <anchor>a21efc57eea29c3139855909ad4807984</anchor>
+ <arglist>(iterator_type i)</arglist>
+ </member>
+ <member kind="function" protection="protected">
+ <type>internal::signal_impl *</type>
+ <name>impl</name>
+ <anchorfile>structsigc_1_1signal__base.html</anchorfile>
+ <anchor>ab0527d817989f2386556ce164c3adfa7</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function" protection="protected">
+ <type>iterator_type</type>
+ <name>insert</name>
+ <anchorfile>structsigc_1_1signal__base.html</anchorfile>
+ <anchor>a87da23ad801faa9e2b6b4be2a747e757</anchor>
+ <arglist>(iterator_type i, const slot_base &slot_)</arglist>
+ </member>
+ <member kind="function" protection="protected">
+ <type>iterator_type</type>
+ <name>insert</name>
+ <anchorfile>structsigc_1_1signal__base.html</anchorfile>
+ <anchor>aa80c33868910139dd2f511afcc31b687</anchor>
+ <arglist>(iterator_type i, slot_base &&slot_)</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>internal::signal_impl *</type>
+ <name>impl_</name>
+ <anchorfile>structsigc_1_1signal__base.html</anchorfile>
+ <anchor>a747d448c28fd256ef580d165eb69f17a</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::slot</name>
+ <filename>classsigc_1_1slot.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>slot7< T_return, nil, nil, nil, nil, nil, nil, nil ></base>
+ <member kind="typedef">
+ <type>slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>parent_type</name>
+ <anchorfile>classsigc_1_1slot.html</anchorfile>
+ <anchor>a1966941e9654adfb3af4b994fd18a7f3</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot.html</anchorfile>
+ <anchor>af643a8ef3eafd24f738224bbd6056fa3</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot.html</anchorfile>
+ <anchor>ac53122c7f0f1f4dd9493e9ac88837ae2</anchor>
+ <arglist>(const slot &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot.html</anchorfile>
+ <anchor>ad790b9eb2c959f0f266dc94c0e84dd35</anchor>
+ <arglist>(const T_functor &_A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot.html</anchorfile>
+ <anchor>a445f8243e1eac20f8f925824c4acf4cf</anchor>
+ <arglist>(slot &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot.html</anchorfile>
+ <anchor>ac7beb1ab973b6cd124d2cdea3f0c1e0c</anchor>
+ <arglist>(const slot &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot.html</anchorfile>
+ <anchor>a0f4ef3f59a7f7228b8b4fddabdbd6924</anchor>
+ <arglist>(slot &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::slot0</name>
+ <filename>classsigc_1_1slot0.html</filename>
+ <templarg></templarg>
+ <base>sigc::slot_base</base>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1slot0.html</anchorfile>
+ <anchor>aca0c967b605e09d5a87015d95e93d4f7</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot0</name>
+ <anchorfile>classsigc_1_1slot0.html</anchorfile>
+ <anchor>a8681082ecd439d5b294922e4d27a3f49</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot0</name>
+ <anchorfile>classsigc_1_1slot0.html</anchorfile>
+ <anchor>acce9a5d9a4f939e405383092ba717f72</anchor>
+ <arglist>(const slot0 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot0</name>
+ <anchorfile>classsigc_1_1slot0.html</anchorfile>
+ <anchor>a83a247c06b93ef644bdfe0bf119929c0</anchor>
+ <arglist>(const T_functor &_A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot0</name>
+ <anchorfile>classsigc_1_1slot0.html</anchorfile>
+ <anchor>ac93b53e3d90df14b2b003ad0c685b160</anchor>
+ <arglist>(slot0 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1slot0.html</anchorfile>
+ <anchor>afa926436a4b0734f0adc2a485ccfe36a</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>slot0 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot0.html</anchorfile>
+ <anchor>a49bba0540dcc76fb19e49d19a1acd563</anchor>
+ <arglist>(const slot0 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot0 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot0.html</anchorfile>
+ <anchor>a95205051379e5d5657bac78c9b3b8d49</anchor>
+ <arglist>(slot0 &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::slot1</name>
+ <filename>classsigc_1_1slot1.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::slot_base</base>
+ <member kind="typedef">
+ <type>type_trait_take_t< T_arg1 ></type>
+ <name>arg1_type_</name>
+ <anchorfile>classsigc_1_1slot1.html</anchorfile>
+ <anchor>a4d81838957a9ccc6cb4c104706a37a89</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1slot1.html</anchorfile>
+ <anchor>ab4991fe5d80761ddab482fda9ebe6d17</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot1</name>
+ <anchorfile>classsigc_1_1slot1.html</anchorfile>
+ <anchor>aa8ac5eadba778c11a424e255889e67f6</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot1</name>
+ <anchorfile>classsigc_1_1slot1.html</anchorfile>
+ <anchor>ac6ecaff0a20a57d2168ea126e565e36a</anchor>
+ <arglist>(const slot1 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot1</name>
+ <anchorfile>classsigc_1_1slot1.html</anchorfile>
+ <anchor>a20999708c6db16a3015beca7d4ad866e</anchor>
+ <arglist>(const T_functor &_A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot1</name>
+ <anchorfile>classsigc_1_1slot1.html</anchorfile>
+ <anchor>a4ab8f18f97f843558f11adb9d1e8e478</anchor>
+ <arglist>(slot1 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1slot1.html</anchorfile>
+ <anchor>ae9082daf31fdbb57da71e8c38a9ae1ab</anchor>
+ <arglist>(arg1_type_ _A_a1) const</arglist>
+ </member>
+ <member kind="function">
+ <type>slot1 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot1.html</anchorfile>
+ <anchor>a2e0d65cfc434718b6c5f7d7135ac384e</anchor>
+ <arglist>(const slot1 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot1 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot1.html</anchorfile>
+ <anchor>a195acd57b42149a2faaeec4c6725825a</anchor>
+ <arglist>(slot1 &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::slot2</name>
+ <filename>classsigc_1_1slot2.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::slot_base</base>
+ <member kind="typedef">
+ <type>type_trait_take_t< T_arg1 ></type>
+ <name>arg1_type_</name>
+ <anchorfile>classsigc_1_1slot2.html</anchorfile>
+ <anchor>ae69b03a4119d61a0a521b0ad5ddaae46</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>type_trait_take_t< T_arg2 ></type>
+ <name>arg2_type_</name>
+ <anchorfile>classsigc_1_1slot2.html</anchorfile>
+ <anchor>af03b1377bbfcdc742a7c00f4c2c419f7</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1slot2.html</anchorfile>
+ <anchor>a0bb920e3d5628c3d01a4337a2a8a97fc</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot2</name>
+ <anchorfile>classsigc_1_1slot2.html</anchorfile>
+ <anchor>a3f9f6cf199bbb40011eca25eb9da67c2</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot2</name>
+ <anchorfile>classsigc_1_1slot2.html</anchorfile>
+ <anchor>a868deef9d947dfa4fcbb0cfe64cbd42e</anchor>
+ <arglist>(const slot2 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot2</name>
+ <anchorfile>classsigc_1_1slot2.html</anchorfile>
+ <anchor>a14641110a8fdbb060a58c037b9000730</anchor>
+ <arglist>(const T_functor &_A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot2</name>
+ <anchorfile>classsigc_1_1slot2.html</anchorfile>
+ <anchor>a4719ba9494f87e682b6a6d04b02413e7</anchor>
+ <arglist>(slot2 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1slot2.html</anchorfile>
+ <anchor>aa2abda2a910db19bbb7a2a08d867e358</anchor>
+ <arglist>(arg1_type_ _A_a1, arg2_type_ _A_a2) const</arglist>
+ </member>
+ <member kind="function">
+ <type>slot2 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot2.html</anchorfile>
+ <anchor>a6b3d5de4d2e7a6134cc883b98380caa7</anchor>
+ <arglist>(const slot2 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot2 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot2.html</anchorfile>
+ <anchor>aeda5a84c674376aa0800a0bf876bb5fa</anchor>
+ <arglist>(slot2 &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::slot3</name>
+ <filename>classsigc_1_1slot3.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::slot_base</base>
+ <member kind="typedef">
+ <type>type_trait_take_t< T_arg1 ></type>
+ <name>arg1_type_</name>
+ <anchorfile>classsigc_1_1slot3.html</anchorfile>
+ <anchor>ac6791fffc805aa2303713fea377dbaae</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>type_trait_take_t< T_arg2 ></type>
+ <name>arg2_type_</name>
+ <anchorfile>classsigc_1_1slot3.html</anchorfile>
+ <anchor>a7390ac1945e87a1e0d172fe266a58d72</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>type_trait_take_t< T_arg3 ></type>
+ <name>arg3_type_</name>
+ <anchorfile>classsigc_1_1slot3.html</anchorfile>
+ <anchor>a54a09bfe0dd9c518ec22cc14a7e43a23</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1slot3.html</anchorfile>
+ <anchor>a69cca26f164c63de6ffa70a3806fb936</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot3</name>
+ <anchorfile>classsigc_1_1slot3.html</anchorfile>
+ <anchor>ac477d74beed45b2b3e26d19b083147ad</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot3</name>
+ <anchorfile>classsigc_1_1slot3.html</anchorfile>
+ <anchor>afa87acf0475e178f8d970bf05f84b04b</anchor>
+ <arglist>(const slot3 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot3</name>
+ <anchorfile>classsigc_1_1slot3.html</anchorfile>
+ <anchor>aeb40907cf0589e97fd541c71e368ad03</anchor>
+ <arglist>(const T_functor &_A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot3</name>
+ <anchorfile>classsigc_1_1slot3.html</anchorfile>
+ <anchor>a74644090c829923a4dda5e09f932d4f9</anchor>
+ <arglist>(slot3 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1slot3.html</anchorfile>
+ <anchor>addbe340b1f547308035707236e690e66</anchor>
+ <arglist>(arg1_type_ _A_a1, arg2_type_ _A_a2, arg3_type_ _A_a3) const</arglist>
+ </member>
+ <member kind="function">
+ <type>slot3 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot3.html</anchorfile>
+ <anchor>a2ff8f9202019d25ddab688128c504e72</anchor>
+ <arglist>(const slot3 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot3 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot3.html</anchorfile>
+ <anchor>ac40a1cefaf9c356a691dfea6819094b8</anchor>
+ <arglist>(slot3 &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::slot4</name>
+ <filename>classsigc_1_1slot4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::slot_base</base>
+ <member kind="typedef">
+ <type>type_trait_take_t< T_arg1 ></type>
+ <name>arg1_type_</name>
+ <anchorfile>classsigc_1_1slot4.html</anchorfile>
+ <anchor>a4426d0dcf517d0d815d6add3c9490437</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>type_trait_take_t< T_arg2 ></type>
+ <name>arg2_type_</name>
+ <anchorfile>classsigc_1_1slot4.html</anchorfile>
+ <anchor>abf1d276525f0120a734b2b054b9cfb3f</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>type_trait_take_t< T_arg3 ></type>
+ <name>arg3_type_</name>
+ <anchorfile>classsigc_1_1slot4.html</anchorfile>
+ <anchor>ae1af3fbe3981779b68f5676f46f6085c</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>type_trait_take_t< T_arg4 ></type>
+ <name>arg4_type_</name>
+ <anchorfile>classsigc_1_1slot4.html</anchorfile>
+ <anchor>aec7f4747dbe5b581c65c07033ca1bfe5</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1slot4.html</anchorfile>
+ <anchor>a3f6b5b11385536c1c199ca29468c638a</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot4</name>
+ <anchorfile>classsigc_1_1slot4.html</anchorfile>
+ <anchor>a4b8ef0494eea86c0d787486ce121db91</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot4</name>
+ <anchorfile>classsigc_1_1slot4.html</anchorfile>
+ <anchor>a7b7080168e769cdec8d916f71fa58d21</anchor>
+ <arglist>(const slot4 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot4</name>
+ <anchorfile>classsigc_1_1slot4.html</anchorfile>
+ <anchor>a50d331d378ba1f3cb03f39a42a4aa3cf</anchor>
+ <arglist>(const T_functor &_A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot4</name>
+ <anchorfile>classsigc_1_1slot4.html</anchorfile>
+ <anchor>acf9e9b169fddb40079618f870172f535</anchor>
+ <arglist>(slot4 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1slot4.html</anchorfile>
+ <anchor>a02b0d861a47418b9dbf73ab7db67b0a9</anchor>
+ <arglist>(arg1_type_ _A_a1, arg2_type_ _A_a2, arg3_type_ _A_a3, arg4_type_ _A_a4) const</arglist>
+ </member>
+ <member kind="function">
+ <type>slot4 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot4.html</anchorfile>
+ <anchor>ac2fb7f8ae312ced5b7436f0a0d062132</anchor>
+ <arglist>(const slot4 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot4 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot4.html</anchorfile>
+ <anchor>ad05b8c996262ab1bcac89d8c8004a0b5</anchor>
+ <arglist>(slot4 &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::slot5</name>
+ <filename>classsigc_1_1slot5.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::slot_base</base>
+ <member kind="typedef">
+ <type>type_trait_take_t< T_arg1 ></type>
+ <name>arg1_type_</name>
+ <anchorfile>classsigc_1_1slot5.html</anchorfile>
+ <anchor>aeda4706cbac7cb87a276ffeb8bdada16</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>type_trait_take_t< T_arg2 ></type>
+ <name>arg2_type_</name>
+ <anchorfile>classsigc_1_1slot5.html</anchorfile>
+ <anchor>ad93d2b3cdce1c3990bde0f49693096e1</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>type_trait_take_t< T_arg3 ></type>
+ <name>arg3_type_</name>
+ <anchorfile>classsigc_1_1slot5.html</anchorfile>
+ <anchor>aab17d4f2a38e02219c1a4757ba268baf</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>type_trait_take_t< T_arg4 ></type>
+ <name>arg4_type_</name>
+ <anchorfile>classsigc_1_1slot5.html</anchorfile>
+ <anchor>afe7fd46dc4b01397db2c2a9c70b02735</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>type_trait_take_t< T_arg5 ></type>
+ <name>arg5_type_</name>
+ <anchorfile>classsigc_1_1slot5.html</anchorfile>
+ <anchor>ade67aef04bbfd7c6af63e93afc709321</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1slot5.html</anchorfile>
+ <anchor>aac50a6486dddcac3a42022a6f2189f09</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot5</name>
+ <anchorfile>classsigc_1_1slot5.html</anchorfile>
+ <anchor>a7548f0d175acd8296064c9bc6d76ea88</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot5</name>
+ <anchorfile>classsigc_1_1slot5.html</anchorfile>
+ <anchor>ad54fd2ef5f50844c214f1a5fbaef9299</anchor>
+ <arglist>(const slot5 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot5</name>
+ <anchorfile>classsigc_1_1slot5.html</anchorfile>
+ <anchor>abcf315edb57a1a23ab7f4a0d25e57736</anchor>
+ <arglist>(const T_functor &_A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot5</name>
+ <anchorfile>classsigc_1_1slot5.html</anchorfile>
+ <anchor>a9c7dc2f187084d174ea9f834178d491d</anchor>
+ <arglist>(slot5 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1slot5.html</anchorfile>
+ <anchor>a3f2d9fa2c9747d6c7fc329213446c71d</anchor>
+ <arglist>(arg1_type_ _A_a1, arg2_type_ _A_a2, arg3_type_ _A_a3, arg4_type_ _A_a4, arg5_type_ _A_a5) const</arglist>
+ </member>
+ <member kind="function">
+ <type>slot5 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot5.html</anchorfile>
+ <anchor>a24d22be7be827080b34109c625bad7fd</anchor>
+ <arglist>(const slot5 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot5 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot5.html</anchorfile>
+ <anchor>af000284699d7f5594599f6e742f64e4a</anchor>
+ <arglist>(slot5 &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::slot6</name>
+ <filename>classsigc_1_1slot6.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::slot_base</base>
+ <member kind="typedef">
+ <type>type_trait_take_t< T_arg1 ></type>
+ <name>arg1_type_</name>
+ <anchorfile>classsigc_1_1slot6.html</anchorfile>
+ <anchor>a98240591834da17569f94410684120ba</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>type_trait_take_t< T_arg2 ></type>
+ <name>arg2_type_</name>
+ <anchorfile>classsigc_1_1slot6.html</anchorfile>
+ <anchor>a44b34c5068d0150922cc630400a1962a</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>type_trait_take_t< T_arg3 ></type>
+ <name>arg3_type_</name>
+ <anchorfile>classsigc_1_1slot6.html</anchorfile>
+ <anchor>a05f153d441986f23d115bf29c92736ca</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>type_trait_take_t< T_arg4 ></type>
+ <name>arg4_type_</name>
+ <anchorfile>classsigc_1_1slot6.html</anchorfile>
+ <anchor>a285a8d86913eff1b27b89f4d795190c1</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>type_trait_take_t< T_arg5 ></type>
+ <name>arg5_type_</name>
+ <anchorfile>classsigc_1_1slot6.html</anchorfile>
+ <anchor>a4a304a22b1a1fae56b7998ae4ae3c0e1</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>type_trait_take_t< T_arg6 ></type>
+ <name>arg6_type_</name>
+ <anchorfile>classsigc_1_1slot6.html</anchorfile>
+ <anchor>ae935d9ad4042e4cfb0730e2855d7882e</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1slot6.html</anchorfile>
+ <anchor>a8dae48d6160e0f917f545eb10950a9bf</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot6</name>
+ <anchorfile>classsigc_1_1slot6.html</anchorfile>
+ <anchor>a3c763adcaa8b9c34c808ef0f15b1fc48</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot6</name>
+ <anchorfile>classsigc_1_1slot6.html</anchorfile>
+ <anchor>a7e4c0f209961d3797f6fadfe9d1c6078</anchor>
+ <arglist>(const slot6 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot6</name>
+ <anchorfile>classsigc_1_1slot6.html</anchorfile>
+ <anchor>a7458f98cd4ed4a9aa6671ea9f0c260f2</anchor>
+ <arglist>(const T_functor &_A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot6</name>
+ <anchorfile>classsigc_1_1slot6.html</anchorfile>
+ <anchor>af7132887ca029e0325d46baa2026bea4</anchor>
+ <arglist>(slot6 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1slot6.html</anchorfile>
+ <anchor>ac2d6449f2928138c434c474050c7c192</anchor>
+ <arglist>(arg1_type_ _A_a1, arg2_type_ _A_a2, arg3_type_ _A_a3, arg4_type_ _A_a4, arg5_type_ _A_a5, arg6_type_ _A_a6) const</arglist>
+ </member>
+ <member kind="function">
+ <type>slot6 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot6.html</anchorfile>
+ <anchor>a7d13ed520a19d287719bd24050b7d8a2</anchor>
+ <arglist>(const slot6 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot6 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot6.html</anchorfile>
+ <anchor>a078ab12d6b08bd132041b4787f99ea85</anchor>
+ <arglist>(slot6 &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::slot7</name>
+ <filename>classsigc_1_1slot7.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::slot_base</base>
+ <member kind="typedef">
+ <type>type_trait_take_t< T_arg1 ></type>
+ <name>arg1_type_</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>a58edf93a837003d1a69fc77d39fc11a9</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>type_trait_take_t< T_arg2 ></type>
+ <name>arg2_type_</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>ad144d8ea3ecb891d358b5b1b969be7e2</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>type_trait_take_t< T_arg3 ></type>
+ <name>arg3_type_</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>af90cd5954008a84d6459d99de152a08c</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>type_trait_take_t< T_arg4 ></type>
+ <name>arg4_type_</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>af42bc9af248b7c2226d93230bd7b1024</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>type_trait_take_t< T_arg5 ></type>
+ <name>arg5_type_</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>ad6c1006a29f6fcb721bc39e8d6f82323</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>type_trait_take_t< T_arg6 ></type>
+ <name>arg6_type_</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>ae25a8a8663addfce52415a20725a3b3e</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>type_trait_take_t< T_arg7 ></type>
+ <name>arg7_type_</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>a2dc6c96b8d014fab9daea823188ca021</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>a06a374d3304636cb48fed29542dc851f</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot7</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>abf200ae4152fb26fc96a6863be3548b8</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot7</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>a6411349bb6f8d7151f41ae7772e61f6d</anchor>
+ <arglist>(const slot7 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot7</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>aa9b64dc6516b8a0d55f46e4737eaaf8b</anchor>
+ <arglist>(const T_functor &_A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot7</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>a69a267bb61931f4ea039048d3221517c</anchor>
+ <arglist>(slot7 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>a28e18e1a9adc88a4758be7d2497fc88d</anchor>
+ <arglist>(arg1_type_ _A_a1, arg2_type_ _A_a2, arg3_type_ _A_a3, arg4_type_ _A_a4, arg5_type_ _A_a5, arg6_type_ _A_a6, arg7_type_ _A_a7) const</arglist>
+ </member>
+ <member kind="function">
+ <type>slot7 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>af6bf09a0b3c09245257af113e70269d2</anchor>
+ <arglist>(const slot7 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot7 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>a82b499c48909c51c4dad097885804638</anchor>
+ <arglist>(slot7 &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::slot< T_return(T_arg...)></name>
+ <filename>classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html</filename>
+ <templarg></templarg>
+ <templarg>T_arg</templarg>
+ <base>sigc::slot_base</base>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html</anchorfile>
+ <anchor>af593e79280c004b6ef8f4722953df0c4</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html</anchorfile>
+ <anchor>add0d65ea6dc554733e766b3510c89a3a</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html</anchorfile>
+ <anchor>ad1e5bc73a259ee666eb8d11d9e48d1d7</anchor>
+ <arglist>(const slot &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html</anchorfile>
+ <anchor>a8c7a2fb604a0a9495bfa2850bb3520f5</anchor>
+ <arglist>(const T_functor &_A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html</anchorfile>
+ <anchor>ae7d852d9ac2c9a6a37564a0f4aed3872</anchor>
+ <arglist>(slot &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html</anchorfile>
+ <anchor>a4038d1a1c7a34bbb344b61a8f43c23f6</anchor>
+ <arglist>(type_trait_take_t< T_arg >... _A_a) const</arglist>
+ </member>
+ <member kind="function">
+ <type>slot &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html</anchorfile>
+ <anchor>a34e1ec92ebbc3ee4dbc8acdeb525c12c</anchor>
+ <arglist>(const slot &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_07T__arg_8_8_8_08_4.html</anchorfile>
+ <anchor>a22759a1af0d37b9e7432bbb046ceff8a</anchor>
+ <arglist>(slot &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil ></name>
+ <filename>classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</filename>
+ <templarg></templarg>
+ <base>sigc::slot0</base>
+ <member kind="typedef">
+ <type>slot0< T_return ></type>
+ <name>parent_type</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a9937c7fbdb8be4e387fddcebf328fa41</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>abdb48282bb8b1b5404fcea6474eca5a5</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a9312dc3f121832083362b21334b939d2</anchor>
+ <arglist>(const slot &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>ad35c264a95bfb4f29ed1fac4fda05a48</anchor>
+ <arglist>(const T_functor &_A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>aaf79a4f6ed84e20f9a800daa4f625d57</anchor>
+ <arglist>(slot &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a62c6b78bd545f7b6a2b0b85a6c3e6b00</anchor>
+ <arglist>(const slot &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>aba4c957436ba517b8b21a58e75ef9253</anchor>
+ <arglist>(slot &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></name>
+ <filename>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::slot1</base>
+ <member kind="typedef">
+ <type>slot1< T_return, T_arg1 ></type>
+ <name>parent_type</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a2b6b5b8590577c765c7a32f7e619250a</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>ad34e10be904557368c241f53e972c8e7</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a2765416a5563c2d264c892aa6ab5a83c</anchor>
+ <arglist>(const slot &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a5d486e3227ed5f73b791c4e202a168b4</anchor>
+ <arglist>(const T_functor &_A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>ad22e5b50e474d072bb17489e9342c478</anchor>
+ <arglist>(slot &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a50efa6d5ba0613851a7aac56b98f7eb8</anchor>
+ <arglist>(const slot &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a88a00e43c5ed084441655b2f9e32c621</anchor>
+ <arglist>(slot &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></name>
+ <filename>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::slot2</base>
+ <member kind="typedef">
+ <type>slot2< T_return, T_arg1, T_arg2 ></type>
+ <name>parent_type</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a867e776b644ca32a703866a424ae3ba5</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>aae3ba9ffc1ab8ea95ba75dd6f5753c48</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a7b7a49a2270daf31abdc237d440b21b1</anchor>
+ <arglist>(const slot &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a32b5350736a34c13c5e64d3ef6f5ba84</anchor>
+ <arglist>(const T_functor &_A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>ad034a7e1a5344031ee9764c063054814</anchor>
+ <arglist>(slot &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>aa2298b81729a3f9879283a99ac31dfaf</anchor>
+ <arglist>(const slot &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01nil_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a98c52bf9ca78dc5f940ec5f5ca466bd9</anchor>
+ <arglist>(slot &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></name>
+ <filename>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::slot3</base>
+ <member kind="typedef">
+ <type>slot3< T_return, T_arg1, T_arg2, T_arg3 ></type>
+ <name>parent_type</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>adbafac5ab39a4a017406ac9587c9511c</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>ad99678bf6a2affc9a1607046e158b22b</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a508b21923e1ef3d7d689984132d89360</anchor>
+ <arglist>(const slot &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a492069e82b787edc381f4583bc1ab16d</anchor>
+ <arglist>(const T_functor &_A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a0e8a890566381060e52ffbd74cc4cca4</anchor>
+ <arglist>(slot &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a355a28cb253c5a14fb36574316f40e3b</anchor>
+ <arglist>(const slot &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01nil_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a190287bba2fd66fd0448c586660d1e41</anchor>
+ <arglist>(slot &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></name>
+ <filename>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::slot4</base>
+ <member kind="typedef">
+ <type>slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>parent_type</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a704393344c1ba2f6bdda9b466bb81af1</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>afb4ec5a164ca622ab9c1a97e61e9cfdc</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>afb9ff761d6f8519ea01b4fd1c254ee60</anchor>
+ <arglist>(const slot &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>aa2691c7a5f59f54788db1b31d4870650</anchor>
+ <arglist>(const T_functor &_A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a4e1e1ecd839575d1d928325f8882fbfb</anchor>
+ <arglist>(slot &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>aebe6238dace66568d5135f1a7d41e8d1</anchor>
+ <arglist>(const slot &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01nil_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a0b0b9caae71710771aa3cd90f93755c5</anchor>
+ <arglist>(slot &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></name>
+ <filename>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::slot5</base>
+ <member kind="typedef">
+ <type>slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>parent_type</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a013f4139332e23166f7db3be6da4ba91</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a81c9e625279217aee1ae00696927c39e</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>afab26283085a050db6d75a1bfe273f86</anchor>
+ <arglist>(const slot &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a8d5f076fe0207cabd9b2632382bedd89</anchor>
+ <arglist>(const T_functor &_A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>aad4ab45a94e4ec0bddf66c4d88e38b0a</anchor>
+ <arglist>(slot &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a3ca127357feda698616f9ed7209653ff</anchor>
+ <arglist>(const slot &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01nil_00_01nil_01_4.html</anchorfile>
+ <anchor>a3195ba5b04503a37525bf2142c704f70</anchor>
+ <arglist>(slot &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></name>
+ <filename>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::slot6</base>
+ <member kind="typedef">
+ <type>slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>parent_type</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html</anchorfile>
+ <anchor>a9c9028da9fc75a10c6c396673159d471</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html</anchorfile>
+ <anchor>a290753f903665f059c25a4f71c9a9e16</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html</anchorfile>
+ <anchor>a8be1480e392dcaa57d47e1c2a132edd4</anchor>
+ <arglist>(const slot &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html</anchorfile>
+ <anchor>ab3081b23ab4fee6191cd8a2f57ba199d</anchor>
+ <arglist>(const T_functor &_A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html</anchorfile>
+ <anchor>a139944017d26e32ec7a347d94a1fc952</anchor>
+ <arglist>(slot &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html</anchorfile>
+ <anchor>a5146567efe93808fbba32c114d2f302e</anchor>
+ <arglist>(const slot &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot_3_01T__return_00_01T__arg1_00_01T__arg2_00_01T__arg3_00_01T__arg4_00_01T__arg5_00_01T__arg6_00_01nil_01_4.html</anchorfile>
+ <anchor>ace5ff8e4e75675985f148a3d2af0ce64</anchor>
+ <arglist>(slot &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::slot_base</name>
+ <filename>classsigc_1_1slot__base.html</filename>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>trackable::func_destroy_notify</type>
+ <name>func_destroy_notify</name>
+ <anchorfile>classsigc_1_1slot__base.html</anchorfile>
+ <anchor>a7e1a0c2fe43a42187810e8997abeb341</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot_base</name>
+ <anchorfile>classsigc_1_1slot__base.html</anchorfile>
+ <anchor>a182d5db71ef371838c73bcf1c135cd9a</anchor>
+ <arglist>() noexcept</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot_base</name>
+ <anchorfile>classsigc_1_1slot__base.html</anchorfile>
+ <anchor>aadcbb54832b5207bddf89ac5433b531a</anchor>
+ <arglist>(const slot_base &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot_base</name>
+ <anchorfile>classsigc_1_1slot__base.html</anchorfile>
+ <anchor>a5fbc2bf38a0d9ebcbe13d578d2b3d5a1</anchor>
+ <arglist>(rep_type *rep) noexcept</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot_base</name>
+ <anchorfile>classsigc_1_1slot__base.html</anchorfile>
+ <anchor>ad1fee67a5885e424c275ad0f48fc81b1</anchor>
+ <arglist>(slot_base &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>~slot_base</name>
+ <anchorfile>classsigc_1_1slot__base.html</anchorfile>
+ <anchor>a75c18c50860f63fb020fc2953576ea57</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>add_destroy_notify_callback</name>
+ <anchorfile>classsigc_1_1slot__base.html</anchorfile>
+ <anchor>a8e37cc8f4b57898a288680e59bea2694</anchor>
+ <arglist>(void *data, func_destroy_notify func) const</arglist>
+ </member>
+ <member kind="function">
+ <type>bool</type>
+ <name>block</name>
+ <anchorfile>classsigc_1_1slot__base.html</anchorfile>
+ <anchor>a657a8473164c963a5ca4828c88121bb9</anchor>
+ <arglist>(bool should_block=true) noexcept</arglist>
+ </member>
+ <member kind="function">
+ <type>bool</type>
+ <name>blocked</name>
+ <anchorfile>classsigc_1_1slot__base.html</anchorfile>
+ <anchor>a2f266b6147c4a6bbc5b68994d2dc1517</anchor>
+ <arglist>() const noexcept</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>disconnect</name>
+ <anchorfile>classsigc_1_1slot__base.html</anchorfile>
+ <anchor>a4042d221f7f07a7394d2eb0f14db2857</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>bool</type>
+ <name>empty</name>
+ <anchorfile>classsigc_1_1slot__base.html</anchorfile>
+ <anchor>ae6ac6ca962a1f6a7506d0817165b5cef</anchor>
+ <arglist>() const noexcept</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>operator bool</name>
+ <anchorfile>classsigc_1_1slot__base.html</anchorfile>
+ <anchor>a90d4d7d6037973a94d7dfd7ba9a5feb9</anchor>
+ <arglist>() const noexcept</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_base &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot__base.html</anchorfile>
+ <anchor>a19522528264f1646f8ed982b0042ffad</anchor>
+ <arglist>(const slot_base &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_base &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot__base.html</anchorfile>
+ <anchor>a64e36f28ee61a94c0496fe76f6b3e813</anchor>
+ <arglist>(slot_base &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>remove_destroy_notify_callback</name>
+ <anchorfile>classsigc_1_1slot__base.html</anchorfile>
+ <anchor>a69c55dedaa35626f288754d55b3da66c</anchor>
+ <arglist>(void *data) const</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>set_parent</name>
+ <anchorfile>classsigc_1_1slot__base.html</anchorfile>
+ <anchor>aa7d281de451d5f47923f4ff1c5b7f2c9</anchor>
+ <arglist>(void *parent, void *(*cleanup)(void *)) const noexcept</arglist>
+ </member>
+ <member kind="function">
+ <type>bool</type>
+ <name>unblock</name>
+ <anchorfile>classsigc_1_1slot__base.html</anchorfile>
+ <anchor>a25ad0bd4d2cea4dbfcd09f7d393d266d</anchor>
+ <arglist>() noexcept</arglist>
+ </member>
+ <member kind="variable">
+ <type>bool</type>
+ <name>blocked_</name>
+ <anchorfile>classsigc_1_1slot__base.html</anchorfile>
+ <anchor>a9dc4958860c0f8300b461a743b7f2a2b</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="variable">
+ <type>rep_type *</type>
+ <name>rep_</name>
+ <anchorfile>classsigc_1_1slot__base.html</anchorfile>
+ <anchor>aa482f7dfc73c6950abde0fd51b3125b5</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::slot_const_iterator</name>
+ <filename>structsigc_1_1slot__const__iterator.html</filename>
+ <templarg></templarg>
+ <member kind="typedef">
+ <type>std::ptrdiff_t</type>
+ <name>difference_type</name>
+ <anchorfile>structsigc_1_1slot__const__iterator.html</anchorfile>
+ <anchor>ac111b0a48ab96f75e720f32171072bc5</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>std::bidirectional_iterator_tag</type>
+ <name>iterator_category</name>
+ <anchorfile>structsigc_1_1slot__const__iterator.html</anchorfile>
+ <anchor>afc9dff16373a2fa7a4f373bd48a852c6</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>internal::signal_impl::const_iterator_type</type>
+ <name>iterator_type</name>
+ <anchorfile>structsigc_1_1slot__const__iterator.html</anchorfile>
+ <anchor>a3466a35177b6a0999a12ff0ee10e91b9</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>const T_slot *</type>
+ <name>pointer</name>
+ <anchorfile>structsigc_1_1slot__const__iterator.html</anchorfile>
+ <anchor>a28f3f0d2ac11dd8805d75682d8f38022</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>const T_slot &</type>
+ <name>reference</name>
+ <anchorfile>structsigc_1_1slot__const__iterator.html</anchorfile>
+ <anchor>a8300967b4b29096e7ad0b96db04e095a</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>std::size_t</type>
+ <name>size_type</name>
+ <anchorfile>structsigc_1_1slot__const__iterator.html</anchorfile>
+ <anchor>adb1eeabfa619cbd9565aa0f9429ca5ed</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_slot</type>
+ <name>slot_type</name>
+ <anchorfile>structsigc_1_1slot__const__iterator.html</anchorfile>
+ <anchor>ae377905cad9a91ca23d09877c72d82cd</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_slot</type>
+ <name>value_type</name>
+ <anchorfile>structsigc_1_1slot__const__iterator.html</anchorfile>
+ <anchor>a20a9337066a01a137ea9945bdd509e80</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot_const_iterator</name>
+ <anchorfile>structsigc_1_1slot__const__iterator.html</anchorfile>
+ <anchor>a2b9e80b87a3400bb6f794c07f90d2d47</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot_const_iterator</name>
+ <anchorfile>structsigc_1_1slot__const__iterator.html</anchorfile>
+ <anchor>af84ef3ee54ae482534d88ac6a5b871ae</anchor>
+ <arglist>(const iterator_type &i)</arglist>
+ </member>
+ <member kind="function">
+ <type>bool</type>
+ <name>operator!=</name>
+ <anchorfile>structsigc_1_1slot__const__iterator.html</anchorfile>
+ <anchor>a0139736ee01df37af11f3551d76a2b53</anchor>
+ <arglist>(const slot_const_iterator &other) const</arglist>
+ </member>
+ <member kind="function">
+ <type>reference</type>
+ <name>operator*</name>
+ <anchorfile>structsigc_1_1slot__const__iterator.html</anchorfile>
+ <anchor>a37c9a5d5bba252e41a628bd1c87fd883</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_const_iterator &</type>
+ <name>operator++</name>
+ <anchorfile>structsigc_1_1slot__const__iterator.html</anchorfile>
+ <anchor>aed166d716b032a781d2169c919cefdc9</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_const_iterator</type>
+ <name>operator++</name>
+ <anchorfile>structsigc_1_1slot__const__iterator.html</anchorfile>
+ <anchor>aa2f7b6d4c7aa7192fca0bdcc08b74ba6</anchor>
+ <arglist>(int)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_const_iterator &</type>
+ <name>operator--</name>
+ <anchorfile>structsigc_1_1slot__const__iterator.html</anchorfile>
+ <anchor>a1c1d7d7798914c80d6a60d87c4b24c0a</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_const_iterator</type>
+ <name>operator--</name>
+ <anchorfile>structsigc_1_1slot__const__iterator.html</anchorfile>
+ <anchor>a9ece84f63e078754915dcc6dc6ee1cc4</anchor>
+ <arglist>(int)</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer</type>
+ <name>operator-></name>
+ <anchorfile>structsigc_1_1slot__const__iterator.html</anchorfile>
+ <anchor>afd0ff56e0779787da2c7dfdb0ef4630c</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>bool</type>
+ <name>operator==</name>
+ <anchorfile>structsigc_1_1slot__const__iterator.html</anchorfile>
+ <anchor>af88c3fcadb7ce415fcad4bd5dafad087</anchor>
+ <arglist>(const slot_const_iterator &other) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>iterator_type</type>
+ <name>i_</name>
+ <anchorfile>structsigc_1_1slot__const__iterator.html</anchorfile>
+ <anchor>a5e8020f4f1c3da18fcac4c9babee306f</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::slot_iterator</name>
+ <filename>structsigc_1_1slot__iterator.html</filename>
+ <templarg></templarg>
+ <member kind="typedef">
+ <type>std::ptrdiff_t</type>
+ <name>difference_type</name>
+ <anchorfile>structsigc_1_1slot__iterator.html</anchorfile>
+ <anchor>adb6307ee06c592d67ecef0607f319d5e</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>std::bidirectional_iterator_tag</type>
+ <name>iterator_category</name>
+ <anchorfile>structsigc_1_1slot__iterator.html</anchorfile>
+ <anchor>a0c882521b418b9faaac879a1d337ace5</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>internal::signal_impl::iterator_type</type>
+ <name>iterator_type</name>
+ <anchorfile>structsigc_1_1slot__iterator.html</anchorfile>
+ <anchor>a189fa620b9d90dc1a224d9ad91da5011</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_slot *</type>
+ <name>pointer</name>
+ <anchorfile>structsigc_1_1slot__iterator.html</anchorfile>
+ <anchor>afb36f2add6064e0d7e7ae63ee2ddcde9</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_slot &</type>
+ <name>reference</name>
+ <anchorfile>structsigc_1_1slot__iterator.html</anchorfile>
+ <anchor>aa3e69a557b73d817a1951af1b1767632</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>std::size_t</type>
+ <name>size_type</name>
+ <anchorfile>structsigc_1_1slot__iterator.html</anchorfile>
+ <anchor>a1dd8ea0a80b5bb0f936833a1c2e363ed</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_slot</type>
+ <name>slot_type</name>
+ <anchorfile>structsigc_1_1slot__iterator.html</anchorfile>
+ <anchor>af7a0ed93fca0064021d77275305e04a9</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_slot</type>
+ <name>value_type</name>
+ <anchorfile>structsigc_1_1slot__iterator.html</anchorfile>
+ <anchor>a94f7fcbd3224e1f7e88b84f9e326b0b3</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot_iterator</name>
+ <anchorfile>structsigc_1_1slot__iterator.html</anchorfile>
+ <anchor>a82d4023ad9dc38dcde4cae6bf65cd8c8</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot_iterator</name>
+ <anchorfile>structsigc_1_1slot__iterator.html</anchorfile>
+ <anchor>a07933d72e788285673121e5ce019a260</anchor>
+ <arglist>(const iterator_type &i)</arglist>
+ </member>
+ <member kind="function">
+ <type>bool</type>
+ <name>operator!=</name>
+ <anchorfile>structsigc_1_1slot__iterator.html</anchorfile>
+ <anchor>a880c8929759eca2fc7fb55cb0c813c55</anchor>
+ <arglist>(const slot_iterator &other) const</arglist>
+ </member>
+ <member kind="function">
+ <type>reference</type>
+ <name>operator*</name>
+ <anchorfile>structsigc_1_1slot__iterator.html</anchorfile>
+ <anchor>aa01dddd6f7b4e1a726a55cd1d430f398</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_iterator &</type>
+ <name>operator++</name>
+ <anchorfile>structsigc_1_1slot__iterator.html</anchorfile>
+ <anchor>af5a3b852c1c6e8f69c41f64a17204758</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_iterator</type>
+ <name>operator++</name>
+ <anchorfile>structsigc_1_1slot__iterator.html</anchorfile>
+ <anchor>a7469f1ad5f1802d7a04f031ee4b3e54e</anchor>
+ <arglist>(int)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_iterator &</type>
+ <name>operator--</name>
+ <anchorfile>structsigc_1_1slot__iterator.html</anchorfile>
+ <anchor>a8aeef4e41dc0930beaa8d6a37b27775c</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_iterator</type>
+ <name>operator--</name>
+ <anchorfile>structsigc_1_1slot__iterator.html</anchorfile>
+ <anchor>afd2ebfa71c2df96290f2bce0746d6fa5</anchor>
+ <arglist>(int)</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer</type>
+ <name>operator-></name>
+ <anchorfile>structsigc_1_1slot__iterator.html</anchorfile>
+ <anchor>a0a77bd2eccf05cecbdf3b690c5301540</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>bool</type>
+ <name>operator==</name>
+ <anchorfile>structsigc_1_1slot__iterator.html</anchorfile>
+ <anchor>af2b4e16f15258f6cd98f8049afd0b88d</anchor>
+ <arglist>(const slot_iterator &other) const</arglist>
+ </member>
+ <member kind="variable">
+ <type>iterator_type</type>
+ <name>i_</name>
+ <anchorfile>structsigc_1_1slot__iterator.html</anchorfile>
+ <anchor>a5e113a9e58ce7e16a11838a203b72649</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::slot_list</name>
+ <filename>structsigc_1_1slot__list.html</filename>
+ <templarg></templarg>
+ <member kind="typedef">
+ <type>slot_const_iterator< slot_type ></type>
+ <name>const_iterator</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>a957838a7111e132824c10c2d5a897a0b</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>const slot_type &</type>
+ <name>const_reference</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>a3ac6e61271e7e8623d1bd493c61f1214</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>std::reverse_iterator< const_iterator ></type>
+ <name>const_reverse_iterator</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>a8293bfca54539958326f57375e4d8c14</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_iterator< slot_type ></type>
+ <name>iterator</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>a9774e07e467d9463e6e7cc7aa2f5c05f</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_type &</type>
+ <name>reference</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>ab0f2255639f24ff02d45f97994bc0e11</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>std::reverse_iterator< iterator ></type>
+ <name>reverse_iterator</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>addb44a7590825f917b3fcf0179fadadb</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_slot</type>
+ <name>slot_type</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>af769819a62b19adb888eb231709e894f</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot_list</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>aa83ff2d263581f80f9d15d14fa31bc7a</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot_list</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>a5baac8e52fda5f6fc4fa31bed67077e3</anchor>
+ <arglist>(internal::signal_impl *__list)</arglist>
+ </member>
+ <member kind="function">
+ <type>reference</type>
+ <name>back</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>a2b1145f2e387c041913d01b5b197f12b</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const_reference</type>
+ <name>back</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>a09c5090912b6a7920269d3959e9698f4</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>begin</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>ae179ec4300ddc793492bc574f6a92fec</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const_iterator</type>
+ <name>begin</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>af5d0b9141e3206f2a7512e1ac4cc65fc</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>end</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>affef6e4e62e4be8743c56aa8753f76d1</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const_iterator</type>
+ <name>end</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>a1d5274891fad64cd2449914728b60bc1</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>erase</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>a76e40607d0329865e549ac78105a5d7d</anchor>
+ <arglist>(iterator first_, iterator last_)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>erase</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>a092ed557b1519062804a41e9b527e99d</anchor>
+ <arglist>(iterator i)</arglist>
+ </member>
+ <member kind="function">
+ <type>reference</type>
+ <name>front</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>abcd398b9cb6fe9506e548d121081163a</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const_reference</type>
+ <name>front</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>ac44ca78cb266a8c46758b276cea151a1</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>insert</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>a34c421956609463692527793e49b87ae</anchor>
+ <arglist>(iterator i, const slot_type &slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>insert</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>ac4e8d8b623aed063b7873b5d2e1ce5f5</anchor>
+ <arglist>(iterator i, slot_type &&slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>pop_back</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>abb28f82ef0cbc78a86a4becd61b0c9ff</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>pop_front</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>a9244005ecc265b07b7f451e63662686e</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>push_back</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>a5c7401657a6020c14616e62b20949de8</anchor>
+ <arglist>(const slot_type &c)</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>push_back</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>a48bf437419930c92756ee3b2162d08ad</anchor>
+ <arglist>(slot_type &&c)</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>push_front</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>a5bb241c13cb363825f787ecd244ebf7d</anchor>
+ <arglist>(const slot_type &c)</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>push_front</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>a4179f2c80be5fb65544b19b3b1d4807e</anchor>
+ <arglist>(slot_type &&c)</arglist>
+ </member>
+ <member kind="function">
+ <type>reverse_iterator</type>
+ <name>rbegin</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>a898411734692d01a320b20a20d9e6978</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const_reverse_iterator</type>
+ <name>rbegin</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>a1d4d33c9ac07a6012332d89100e8fbeb</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>reverse_iterator</type>
+ <name>rend</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>ae4759ca19577b31dca5116292e7de19c</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const_reverse_iterator</type>
+ <name>rend</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>a805f74b49477673660b039576cbec20f</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>internal::signal_impl *</type>
+ <name>list_</name>
+ <anchorfile>structsigc_1_1slot__list.html</anchorfile>
+ <anchor>a2c5b3ecf068ec93cdc34a4ae8d48313c</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::track_obj_functor1</name>
+ <filename>classsigc_1_1track__obj__functor1.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::adapts</base>
+ <member kind="typedef">
+ <type>adapts< T_functor >::adaptor_type</type>
+ <name>adaptor_type</name>
+ <anchorfile>classsigc_1_1track__obj__functor1.html</anchorfile>
+ <anchor>ab36332c8e8815546730b525f739d9ebf</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>adaptor_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1track__obj__functor1.html</anchorfile>
+ <anchor>a17ad87a124cb6fafc37a2d573d47f222</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>track_obj_functor1</name>
+ <anchorfile>classsigc_1_1track__obj__functor1.html</anchorfile>
+ <anchor>a1bcc00d3b665af8f40fa18936fab5304</anchor>
+ <arglist>(const T_functor &_A_func, const T_obj1 &_A_obj1)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1track__obj__functor1.html</anchorfile>
+ <anchor>a3a4b2ca8d1c83356dcf7d5ba93051986</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1 >::type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1track__obj__functor1.html</anchorfile>
+ <anchor>a3da19bfd10f0b9f84ae83b06f8211ae6</anchor>
+ <arglist>(T_arg1 _A_arg1)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2 >::type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1track__obj__functor1.html</anchorfile>
+ <anchor>a933452a80a7c98d4865624d2f60b2527</anchor>
+ <arglist>(T_arg1 _A_arg1, T_arg2 _A_arg2)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3 >::type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1track__obj__functor1.html</anchorfile>
+ <anchor>abb1206272535caa14e1109d198ab0b1f</anchor>
+ <arglist>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4 >::type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1track__obj__functor1.html</anchorfile>
+ <anchor>a94fba99da25a041007a4f2f07b19c784</anchor>
+ <arglist>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >::type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1track__obj__functor1.html</anchorfile>
+ <anchor>a8bf05204e43be21b027a79ffb7aed13e</anchor>
+ <arglist>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >::type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1track__obj__functor1.html</anchorfile>
+ <anchor>a610d215dd82c2a3112aef9bb29edd856</anchor>
+ <arglist>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)</arglist>
+ </member>
+ <member kind="function">
+ <type>deduce_result_type< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1track__obj__functor1.html</anchorfile>
+ <anchor>a758ed994bc823ce29001873838384ac0</anchor>
+ <arglist>(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6, T_arg7 _A_arg7)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::track_obj_functor2</name>
+ <filename>classsigc_1_1track__obj__functor2.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::track_obj_functor1</base>
+ <member kind="function">
+ <type></type>
+ <name>track_obj_functor2</name>
+ <anchorfile>classsigc_1_1track__obj__functor2.html</anchorfile>
+ <anchor>ae12b4c85e92a265c011fccf090fa6947</anchor>
+ <arglist>(const T_functor &_A_func, const T_obj1 &_A_obj1, const T_obj2 &_A_obj2)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::track_obj_functor3</name>
+ <filename>classsigc_1_1track__obj__functor3.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::track_obj_functor1</base>
+ <member kind="function">
+ <type></type>
+ <name>track_obj_functor3</name>
+ <anchorfile>classsigc_1_1track__obj__functor3.html</anchorfile>
+ <anchor>add83622dc2ad7cd561d2c59768eea45a</anchor>
+ <arglist>(const T_functor &_A_func, const T_obj1 &_A_obj1, const T_obj2 &_A_obj2, const T_obj3 &_A_obj3)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::track_obj_functor4</name>
+ <filename>classsigc_1_1track__obj__functor4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::track_obj_functor1</base>
+ <member kind="function">
+ <type></type>
+ <name>track_obj_functor4</name>
+ <anchorfile>classsigc_1_1track__obj__functor4.html</anchorfile>
+ <anchor>a29f48beae82cf67da9b70a51da35a2e9</anchor>
+ <arglist>(const T_functor &_A_func, const T_obj1 &_A_obj1, const T_obj2 &_A_obj2, const T_obj3 &_A_obj3, const T_obj4 &_A_obj4)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::track_obj_functor5</name>
+ <filename>classsigc_1_1track__obj__functor5.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::track_obj_functor1</base>
+ <member kind="function">
+ <type></type>
+ <name>track_obj_functor5</name>
+ <anchorfile>classsigc_1_1track__obj__functor5.html</anchorfile>
+ <anchor>a1f0481289e8c48acc4cc6561c8f0c8b6</anchor>
+ <arglist>(const T_functor &_A_func, const T_obj1 &_A_obj1, const T_obj2 &_A_obj2, const T_obj3 &_A_obj3, const T_obj4 &_A_obj4, const T_obj5 &_A_obj5)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::track_obj_functor6</name>
+ <filename>classsigc_1_1track__obj__functor6.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::track_obj_functor1</base>
+ <member kind="function">
+ <type></type>
+ <name>track_obj_functor6</name>
+ <anchorfile>classsigc_1_1track__obj__functor6.html</anchorfile>
+ <anchor>a70b36db3f8cafb77c48269c3e4c68714</anchor>
+ <arglist>(const T_functor &_A_func, const T_obj1 &_A_obj1, const T_obj2 &_A_obj2, const T_obj3 &_A_obj3, const T_obj4 &_A_obj4, const T_obj5 &_A_obj5, const T_obj6 &_A_obj6)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::track_obj_functor7</name>
+ <filename>classsigc_1_1track__obj__functor7.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::track_obj_functor1</base>
+ <member kind="function">
+ <type></type>
+ <name>track_obj_functor7</name>
+ <anchorfile>classsigc_1_1track__obj__functor7.html</anchorfile>
+ <anchor>a77667be610a480c7afdb928533b02651</anchor>
+ <arglist>(const T_functor &_A_func, const T_obj1 &_A_obj1, const T_obj2 &_A_obj2, const T_obj3 &_A_obj3, const T_obj4 &_A_obj4, const T_obj5 &_A_obj5, const T_obj6 &_A_obj6, const T_obj7 &_A_obj7)</arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::trackable</name>
+ <filename>structsigc_1_1trackable.html</filename>
+ <member kind="typedef">
+ <type>internal::func_destroy_notify</type>
+ <name>func_destroy_notify</name>
+ <anchorfile>structsigc_1_1trackable.html</anchorfile>
+ <anchor>a3338954d7565534bd945290b798e13ed</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>trackable</name>
+ <anchorfile>structsigc_1_1trackable.html</anchorfile>
+ <anchor>a7e1348841e762fb41b41c6f2ce9fa073</anchor>
+ <arglist>() noexcept</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>trackable</name>
+ <anchorfile>structsigc_1_1trackable.html</anchorfile>
+ <anchor>ac8431d9452c9698a012597e6560c72fa</anchor>
+ <arglist>(const trackable &src) noexcept</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>trackable</name>
+ <anchorfile>structsigc_1_1trackable.html</anchorfile>
+ <anchor>aba42ed8afb6598106cf68c18a7387f18</anchor>
+ <arglist>(trackable &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>~trackable</name>
+ <anchorfile>structsigc_1_1trackable.html</anchorfile>
+ <anchor>a75587da09e30031db7a2519843f1f4fb</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>add_destroy_notify_callback</name>
+ <anchorfile>structsigc_1_1trackable.html</anchorfile>
+ <anchor>aed95b40846f61b4f202348c71d5913ea</anchor>
+ <arglist>(void *data, func_destroy_notify func) const</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>notify_callbacks</name>
+ <anchorfile>structsigc_1_1trackable.html</anchorfile>
+ <anchor>af2e23cfe7adc1ca844a3350bbac557cb</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>trackable &</type>
+ <name>operator=</name>
+ <anchorfile>structsigc_1_1trackable.html</anchorfile>
+ <anchor>a7494fbad23a65932ff1457d00d4edaf5</anchor>
+ <arglist>(const trackable &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>trackable &</type>
+ <name>operator=</name>
+ <anchorfile>structsigc_1_1trackable.html</anchorfile>
+ <anchor>ac3d61cdb452dc46fcdc8a8d42d9c079d</anchor>
+ <arglist>(trackable &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>remove_destroy_notify_callback</name>
+ <anchorfile>structsigc_1_1trackable.html</anchorfile>
+ <anchor>ad1c1845ff5b356f13b32180077f83cff</anchor>
+ <arglist>(void *data) const</arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::type_trait</name>
+ <filename>structsigc_1_1type__trait.html</filename>
+ <templarg></templarg>
+ <member kind="typedef">
+ <type>T_type &</type>
+ <name>pass</name>
+ <anchorfile>structsigc_1_1type__trait.html</anchorfile>
+ <anchor>aebfa426334f8de7b93031de35d2495e3</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>const T_type &</type>
+ <name>take</name>
+ <anchorfile>structsigc_1_1type__trait.html</anchorfile>
+ <anchor>a191a797ea6e2d851287b8a87b6305157</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::type_trait< const T_type & ></name>
+ <filename>structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html</filename>
+ <templarg></templarg>
+ <member kind="typedef">
+ <type>const T_type &</type>
+ <name>pass</name>
+ <anchorfile>structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html</anchorfile>
+ <anchor>a7b9cd2a3e6e7cf986e4e25e05c665c73</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>const T_type &</type>
+ <name>take</name>
+ <anchorfile>structsigc_1_1type__trait_3_01const_01T__type_01_6_01_4.html</anchorfile>
+ <anchor>a2c3a2a62adee114867045a7f77096435</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::type_trait< T_type & ></name>
+ <filename>structsigc_1_1type__trait_3_01T__type_01_6_01_4.html</filename>
+ <templarg></templarg>
+ <member kind="typedef">
+ <type>T_type &</type>
+ <name>pass</name>
+ <anchorfile>structsigc_1_1type__trait_3_01T__type_01_6_01_4.html</anchorfile>
+ <anchor>a1b24e79fed94df3fc0e7574e0ae1c991</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_type &</type>
+ <name>take</name>
+ <anchorfile>structsigc_1_1type__trait_3_01T__type_01_6_01_4.html</anchorfile>
+ <anchor>a604c7ad05de42e3f9d28ab45c8d865b5</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::type_trait< T_type[N]></name>
+ <filename>structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html</filename>
+ <templarg></templarg>
+ <templarg>N</templarg>
+ <member kind="typedef">
+ <type>T_type *&</type>
+ <name>pass</name>
+ <anchorfile>structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html</anchorfile>
+ <anchor>abfd06dd56be6fda2436e9e15acb1fc72</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>const T_type *&</type>
+ <name>take</name>
+ <anchorfile>structsigc_1_1type__trait_3_01T__type_0fN_0e_4.html</anchorfile>
+ <anchor>a9cb9e2faaa68a89ef1a74b8b7c98d81e</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::type_trait< void ></name>
+ <filename>structsigc_1_1type__trait_3_01void_01_4.html</filename>
+ <member kind="typedef">
+ <type>void</type>
+ <name>pass</name>
+ <anchorfile>structsigc_1_1type__trait_3_01void_01_4.html</anchorfile>
+ <anchor>ab5d97b4ec126f3afeaf67e9a6b05b0be</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>void</type>
+ <name>take</name>
+ <anchorfile>structsigc_1_1type__trait_3_01void_01_4.html</anchorfile>
+ <anchor>a40d187392469ee48d24838ef38531b90</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::unwrap_reference</name>
+ <filename>structsigc_1_1unwrap__reference.html</filename>
+ <templarg></templarg>
+ <member kind="typedef">
+ <type>T_type</type>
+ <name>type</name>
+ <anchorfile>structsigc_1_1unwrap__reference.html</anchorfile>
+ <anchor>af35cad963fc073623282a2fb9c81f02a</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::unwrap_reference< const_reference_wrapper< T_type > ></name>
+ <filename>structsigc_1_1unwrap__reference_3_01const__reference__wrapper_3_01T__type_01_4_01_4.html</filename>
+ <templarg></templarg>
+ <member kind="typedef">
+ <type>const T_type &</type>
+ <name>type</name>
+ <anchorfile>structsigc_1_1unwrap__reference_3_01const__reference__wrapper_3_01T__type_01_4_01_4.html</anchorfile>
+ <anchor>a9820651050b0059841f9a92d9c478ba8</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::unwrap_reference< reference_wrapper< T_type > ></name>
+ <filename>structsigc_1_1unwrap__reference_3_01reference__wrapper_3_01T__type_01_4_01_4.html</filename>
+ <templarg></templarg>
+ <member kind="typedef">
+ <type>T_type &</type>
+ <name>type</name>
+ <anchorfile>structsigc_1_1unwrap__reference_3_01reference__wrapper_3_01T__type_01_4_01_4.html</anchorfile>
+ <anchor>a25182a927492ff79290f9820f7131e58</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::unwrap_reference< std::reference_wrapper< T_type > ></name>
+ <filename>structsigc_1_1unwrap__reference_3_01std_1_1reference__wrapper_3_01T__type_01_4_01_4.html</filename>
+ <templarg></templarg>
+ <member kind="typedef">
+ <type>T_type &</type>
+ <name>type</name>
+ <anchorfile>structsigc_1_1unwrap__reference_3_01std_1_1reference__wrapper_3_01T__type_01_4_01_4.html</anchorfile>
+ <anchor>a2a9edeecf0de1843fb4d218f68ae86c4</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="struct">
+ <name>sigc::visitor</name>
+ <filename>structsigc_1_1visitor.html</filename>
+ <templarg></templarg>
+ <member kind="function" static="yes">
+ <type>static void</type>
+ <name>do_visit_each</name>
+ <anchorfile>structsigc_1_1visitor.html</anchorfile>
+ <anchor>a9fe5d6be845e622a99a0db5d3621d4b3</anchor>
+ <arglist>(const T_action &_A_action, const T_functor &_A_functor)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::volatile_limit_reference</name>
+ <filename>classsigc_1_1volatile__limit__reference.html</filename>
+ <templarg></templarg>
+ <templarg>I_derives_trackable</templarg>
+ <member kind="function">
+ <type></type>
+ <name>volatile_limit_reference</name>
+ <anchorfile>classsigc_1_1volatile__limit__reference.html</anchorfile>
+ <anchor>acb3e6e1ecc628343f94faae718b58066</anchor>
+ <arglist>(T_type &_A_target)</arglist>
+ </member>
+ <member kind="function">
+ <type>volatile T_type &</type>
+ <name>invoke</name>
+ <anchorfile>classsigc_1_1volatile__limit__reference.html</anchorfile>
+ <anchor>a0157cc89d9db4032c7a8f9159ebaeff3</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>const T_type &</type>
+ <name>visit</name>
+ <anchorfile>classsigc_1_1volatile__limit__reference.html</anchorfile>
+ <anchor>a4d67fe2d9d27c326136a9e5ac13a1a75</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::volatile_limit_reference< T_type, true ></name>
+ <filename>classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html</filename>
+ <templarg></templarg>
+ <member kind="function">
+ <type></type>
+ <name>volatile_limit_reference</name>
+ <anchorfile>classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html</anchorfile>
+ <anchor>aa0b69d0a82616d6db2eb86d7a041df23</anchor>
+ <arglist>(T_type &_A_target)</arglist>
+ </member>
+ <member kind="function">
+ <type>volatile T_type &</type>
+ <name>invoke</name>
+ <anchorfile>classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html</anchorfile>
+ <anchor>aebad0975106ae62368e4f5c0ee0a6170</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>const trackable &</type>
+ <name>visit</name>
+ <anchorfile>classsigc_1_1volatile__limit__reference_3_01T__type_00_01true_01_4.html</anchorfile>
+ <anchor>a187454d57b2c1edefb5594fcd0175835</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::volatile_mem_functor0</name>
+ <filename>classsigc_1_1volatile__mem__functor0.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor0.html</anchorfile>
+ <anchor>a2f0448d35b580f2b4884292f29b19b2f</anchor>
+ <arglist>)() volatile</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor0.html</anchorfile>
+ <anchor>a41fbd67d6bbde0818b880f08f6295396</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>volatile_mem_functor0</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor0.html</anchorfile>
+ <anchor>ae29bbe3e668b370d2788631465daa63c</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>volatile_mem_functor0</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor0.html</anchorfile>
+ <anchor>aa4e5e279480d50940eb4b73b9c61b938</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor0.html</anchorfile>
+ <anchor>aa5df40ec8fb385594c673a07f3ff8044</anchor>
+ <arglist>(T_obj &_A_obj) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor0.html</anchorfile>
+ <anchor>af627ef410fac7ec5d2ee842d8f89fe51</anchor>
+ <arglist>(T_obj *_A_obj) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor0.html</anchorfile>
+ <anchor>a874e91ca403b95bb085ed596257de3ec</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::volatile_mem_functor1</name>
+ <filename>classsigc_1_1volatile__mem__functor1.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor1.html</anchorfile>
+ <anchor>a49228c222297c3f116b132370c3f054d</anchor>
+ <arglist>)(T_arg1) volatile</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor1.html</anchorfile>
+ <anchor>a3bcbf6ae6e950d35e4ac7b33fa066877</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>volatile_mem_functor1</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor1.html</anchorfile>
+ <anchor>a30ec3be683a2c466b23da53c8025608b</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>volatile_mem_functor1</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor1.html</anchorfile>
+ <anchor>a86d592aee0ca1d853b64b52224054029</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor1.html</anchorfile>
+ <anchor>a98cdb61b4c623e44d5b60650098bddfd</anchor>
+ <arglist>(T_obj &_A_obj, type_trait_take_t< T_arg1 > _A_a1) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor1.html</anchorfile>
+ <anchor>a69185452103c51af81b78e95504eb95c</anchor>
+ <arglist>(T_obj *_A_obj, type_trait_take_t< T_arg1 > _A_a1) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor1.html</anchorfile>
+ <anchor>ad07b2821f95c27c013af4fdce527c1cb</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::volatile_mem_functor2</name>
+ <filename>classsigc_1_1volatile__mem__functor2.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor2.html</anchorfile>
+ <anchor>a5faa6d84f05d64ff92e9e4ba6b8bcc1f</anchor>
+ <arglist>)(T_arg1, T_arg2) volatile</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor2.html</anchorfile>
+ <anchor>a67719071ed0eacd994fa6fe300cfb24d</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>volatile_mem_functor2</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor2.html</anchorfile>
+ <anchor>a273bbe27bc7b190d8457408cd328c1f9</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>volatile_mem_functor2</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor2.html</anchorfile>
+ <anchor>acba5e052ebb8884ff02cab194a2f794e</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor2.html</anchorfile>
+ <anchor>a814c8abe52fa858da9f8dfbda8efafc9</anchor>
+ <arglist>(T_obj &_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor2.html</anchorfile>
+ <anchor>ac4c64a4812347e17744e33e5e37775d7</anchor>
+ <arglist>(T_obj *_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor2.html</anchorfile>
+ <anchor>aafe942fe06b2687338ea82b058412d07</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::volatile_mem_functor3</name>
+ <filename>classsigc_1_1volatile__mem__functor3.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor3.html</anchorfile>
+ <anchor>aadf62624c12ef82ade8114184f0882c9</anchor>
+ <arglist>)(T_arg1, T_arg2, T_arg3) volatile</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor3.html</anchorfile>
+ <anchor>a229fe43026e97bbcf80215ea8e9fa828</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>volatile_mem_functor3</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor3.html</anchorfile>
+ <anchor>ad2319eebf06194ff516c27f581cbd7a5</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>volatile_mem_functor3</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor3.html</anchorfile>
+ <anchor>a2364e6ab68a8128ba9e9973c66c0ce1d</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor3.html</anchorfile>
+ <anchor>ab525bf6e0a4057a4f3f8f98ff6c1bd74</anchor>
+ <arglist>(T_obj &_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor3.html</anchorfile>
+ <anchor>a39944451f3bb1538828e45b66f082ea0</anchor>
+ <arglist>(T_obj *_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor3.html</anchorfile>
+ <anchor>acf6a8aebcf4de461e03e9b994a807362</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::volatile_mem_functor4</name>
+ <filename>classsigc_1_1volatile__mem__functor4.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor4.html</anchorfile>
+ <anchor>a697cad0c578cd4ba3e04f6db8a39e283</anchor>
+ <arglist>)(T_arg1, T_arg2, T_arg3, T_arg4) volatile</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor4.html</anchorfile>
+ <anchor>a58dd95fa47c02a9ba6340682c7dbbcb0</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>volatile_mem_functor4</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor4.html</anchorfile>
+ <anchor>a5ba462855081b617085e59e7566927a7</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>volatile_mem_functor4</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor4.html</anchorfile>
+ <anchor>ab86348ff91ed7ce4cadff97c157e4024</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor4.html</anchorfile>
+ <anchor>a58491d7fd980863c7abd311624ada052</anchor>
+ <arglist>(T_obj &_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor4.html</anchorfile>
+ <anchor>a86a0e482790971e3674b9ba488e10127</anchor>
+ <arglist>(T_obj *_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor4.html</anchorfile>
+ <anchor>a176ab2202482276e79e6d71ff839c31d</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::volatile_mem_functor5</name>
+ <filename>classsigc_1_1volatile__mem__functor5.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor5.html</anchorfile>
+ <anchor>a43ce719034586bbd097c823376c288ef</anchor>
+ <arglist>)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor5.html</anchorfile>
+ <anchor>ab647ea2e44db475cc2d4bae8be842127</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>volatile_mem_functor5</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor5.html</anchorfile>
+ <anchor>abe1011a71cd8e78d248e072fb7d60231</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>volatile_mem_functor5</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor5.html</anchorfile>
+ <anchor>a98e43ac4bafb96958bbbf658154794d0</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor5.html</anchorfile>
+ <anchor>a4a4b9b8ce1ce396ed9fa355ed56cf7b2</anchor>
+ <arglist>(T_obj &_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor5.html</anchorfile>
+ <anchor>ab6449c487e42fc9810c0f8d5a6cc243f</anchor>
+ <arglist>(T_obj *_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor5.html</anchorfile>
+ <anchor>a01d38ddf6e713a47199fba85fd5a8092</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::volatile_mem_functor6</name>
+ <filename>classsigc_1_1volatile__mem__functor6.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor6.html</anchorfile>
+ <anchor>a67b3a13a2f595360ff6f78cb96efe9d1</anchor>
+ <arglist>)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor6.html</anchorfile>
+ <anchor>a1ce192c145ec5af4c826ccb2619cf002</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>volatile_mem_functor6</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor6.html</anchorfile>
+ <anchor>a782bbd4bff8bd939a008ceb9e0511bae</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>volatile_mem_functor6</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor6.html</anchorfile>
+ <anchor>a55c428dacaaff7f5dcd48ec02b53ed60</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor6.html</anchorfile>
+ <anchor>a2fdda8079c742fd0366c3fc057ea45e5</anchor>
+ <arglist>(T_obj &_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor6.html</anchorfile>
+ <anchor>a00320a319413753f756304a8db0fbf51</anchor>
+ <arglist>(T_obj *_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor6.html</anchorfile>
+ <anchor>aa64e5accf2702a06bffb6ed68fd95022</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>sigc::volatile_mem_functor7</name>
+ <filename>classsigc_1_1volatile__mem__functor7.html</filename>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <templarg></templarg>
+ <base>sigc::functor_base</base>
+ <member kind="typedef">
+ <type>T_return(T_obj::*</type>
+ <name>function_type</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor7.html</anchorfile>
+ <anchor>a4ee701fd029c3b7f2f3a3af1aef428a0</anchor>
+ <arglist>)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile</arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor7.html</anchorfile>
+ <anchor>a4762374376dcb7b11c77372edab78823</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>volatile_mem_functor7</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor7.html</anchorfile>
+ <anchor>a07834a50703bf92aad9bc167fa256d24</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>volatile_mem_functor7</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor7.html</anchorfile>
+ <anchor>a809146646d2dd726a385344f455402e4</anchor>
+ <arglist>(function_type _A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor7.html</anchorfile>
+ <anchor>a05ed4811582f583a1a1e11b1a8951a21</anchor>
+ <arglist>(T_obj &_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor7.html</anchorfile>
+ <anchor>ae587c12caf1c68886fbf001b2c8acc03</anchor>
+ <arglist>(T_obj *_A_obj, type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</arglist>
+ </member>
+ <member kind="variable" protection="protected">
+ <type>function_type</type>
+ <name>func_ptr_</name>
+ <anchorfile>classsigc_1_1volatile__mem__functor7.html</anchorfile>
+ <anchor>ac74b72d519805a654529347e4c638e6f</anchor>
+ <arglist></arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>signal0< T_return, nil ></name>
+ <filename>classsigc_1_1signal0.html</filename>
+ <base>sigc::signal_base</base>
+ <member kind="typedef">
+ <type>slot_list_type::const_iterator</type>
+ <name>const_iterator</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>ad4f7c62954f5c270e115d9b2a2df15ea</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::const_reverse_iterator</type>
+ <name>const_reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a476f559a69eef5999c99cd6262a9aa2f</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>internal::signal_emit0< T_return, nil ></type>
+ <name>emitter_type</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>ac7eafdced2d325d6003327b4360bc2dd</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::iterator</type>
+ <name>iterator</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>ad61e875748cf4e1c2a6d89a930ae093e</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>emitter_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>ae291a90c83f8ad1cdcc7c2a4cdd958de</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::reverse_iterator</type>
+ <name>reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a1d9c390974304392ed12ee81543ab997</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list< slot_type ></type>
+ <name>slot_list_type</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>add195c1c738ee8efe10294f21d258b77</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot< T_return()></type>
+ <name>slot_type</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>ae3fc90cec344b6585979e77d2b359287</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal0</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a2fb24e11a8f645e5122646ea2b4a5d2f</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal0</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a7dc687f1afb4088a3d888aa05dbf56d9</anchor>
+ <arglist>(const signal0 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal0</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>ac1b915a86d0b75fd4e90c2a92f7ebc49</anchor>
+ <arglist>(signal0 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a609b1e0770f47c9081a3de56b65314d2</anchor>
+ <arglist>(const slot_type &slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a9b78954271b6dba5e926bd960f3e7905</anchor>
+ <arglist>(slot_type &&slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a655829125186645bcbc61db8252134a8</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit_reverse</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>abdae39f9a7abd6133c03d65224c227d6</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor0< result_type, signal0 ></type>
+ <name>make_slot</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a3295536428e5e0d6478ac10e2daff736</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a2dd3042c0681542ed6f2de5840f713a1</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>signal0 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a4e8311eac2fd7f8ecd10bff8225ed9e3</anchor>
+ <arglist>(const signal0 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal0 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a693aa3743236012416349bfac56d31b6</anchor>
+ <arglist>(signal0 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a5576113ddfd6b92a96f86072262307f9</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a73523d71edd7fb4294324e9561db6f3c</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>signal0< T_return, T_accumulator ></name>
+ <filename>classsigc_1_1signal0.html</filename>
+ <base>sigc::signal_base</base>
+ <member kind="typedef">
+ <type>slot_list_type::const_iterator</type>
+ <name>const_iterator</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>ad4f7c62954f5c270e115d9b2a2df15ea</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::const_reverse_iterator</type>
+ <name>const_reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a476f559a69eef5999c99cd6262a9aa2f</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>internal::signal_emit0< T_return, T_accumulator ></type>
+ <name>emitter_type</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>ac7eafdced2d325d6003327b4360bc2dd</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::iterator</type>
+ <name>iterator</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>ad61e875748cf4e1c2a6d89a930ae093e</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>emitter_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>ae291a90c83f8ad1cdcc7c2a4cdd958de</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::reverse_iterator</type>
+ <name>reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a1d9c390974304392ed12ee81543ab997</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list< slot_type ></type>
+ <name>slot_list_type</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>add195c1c738ee8efe10294f21d258b77</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot< T_return()></type>
+ <name>slot_type</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>ae3fc90cec344b6585979e77d2b359287</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal0</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a2fb24e11a8f645e5122646ea2b4a5d2f</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal0</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a7dc687f1afb4088a3d888aa05dbf56d9</anchor>
+ <arglist>(const signal0 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal0</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>ac1b915a86d0b75fd4e90c2a92f7ebc49</anchor>
+ <arglist>(signal0 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a609b1e0770f47c9081a3de56b65314d2</anchor>
+ <arglist>(const slot_type &slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a9b78954271b6dba5e926bd960f3e7905</anchor>
+ <arglist>(slot_type &&slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a655829125186645bcbc61db8252134a8</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit_reverse</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>abdae39f9a7abd6133c03d65224c227d6</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor0< result_type, signal0 ></type>
+ <name>make_slot</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a3295536428e5e0d6478ac10e2daff736</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a2dd3042c0681542ed6f2de5840f713a1</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>signal0 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a4e8311eac2fd7f8ecd10bff8225ed9e3</anchor>
+ <arglist>(const signal0 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal0 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a693aa3743236012416349bfac56d31b6</anchor>
+ <arglist>(signal0 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a5576113ddfd6b92a96f86072262307f9</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal0.html</anchorfile>
+ <anchor>a73523d71edd7fb4294324e9561db6f3c</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>signal1< T_return, T_arg1, nil ></name>
+ <filename>classsigc_1_1signal1.html</filename>
+ <base>sigc::signal_base</base>
+ <member kind="typedef">
+ <type>slot_list_type::const_iterator</type>
+ <name>const_iterator</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>af1e262b35c9574e65b2607cdfcaad707</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::const_reverse_iterator</type>
+ <name>const_reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>aeb327519f808dfec9a723511ef82caa3</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>internal::signal_emit1< T_return, T_arg1, nil ></type>
+ <name>emitter_type</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a63c6e2b55c8c3af083402bb7f5a66593</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::iterator</type>
+ <name>iterator</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>ab61e2d1fcaf903dffbb26b01800907fb</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>emitter_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>adcdcfa50d60e1832ce038a4a5554fce1</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::reverse_iterator</type>
+ <name>reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>ab0443049aa736d88770d0f534600b2bc</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list< slot_type ></type>
+ <name>slot_list_type</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a5fadeb350140d6aaf560b217e7e7c4b4</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot< T_return(T_arg1)></type>
+ <name>slot_type</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a310736e1415c2cf4578892ffff35915c</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal1</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>aba62d8d0b9591bcfd728f8ae8a22d600</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal1</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>ab3378dd754ffddb4760f2a3afb271dbe</anchor>
+ <arglist>(const signal1 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal1</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a85ec968e0b25ee9285f297da5416b2a4</anchor>
+ <arglist>(signal1 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>aac2ade0896bd4a982777d5dd6ac75888</anchor>
+ <arglist>(const slot_type &slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>ac69d2681c586b310d8c056a319bb65fe</anchor>
+ <arglist>(slot_type &&slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>affe595f8b70b4f43a21be7192c0cba42</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1) const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit_reverse</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a449fc940ae822c4b6ea9282b9b292015</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1) const</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor1< result_type, signal1, type_trait_take_t< T_arg1 > ></type>
+ <name>make_slot</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a87513117263fd39d5a5a86e0fb8b2a78</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a828907c11f5c18d9522e5d5139484620</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1) const</arglist>
+ </member>
+ <member kind="function">
+ <type>signal1 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a29cd06bf91f96f11c5f29237b8afbb71</anchor>
+ <arglist>(const signal1 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal1 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>ab817711d4bc93402d15e87b89a09c364</anchor>
+ <arglist>(signal1 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a7653b68e6a3b8445de91f89060bf2600</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a7777660b21fef2a6941c7dff23964604</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>signal1< T_return, T_arg1, T_accumulator ></name>
+ <filename>classsigc_1_1signal1.html</filename>
+ <base>sigc::signal_base</base>
+ <member kind="typedef">
+ <type>slot_list_type::const_iterator</type>
+ <name>const_iterator</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>af1e262b35c9574e65b2607cdfcaad707</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::const_reverse_iterator</type>
+ <name>const_reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>aeb327519f808dfec9a723511ef82caa3</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>internal::signal_emit1< T_return, T_arg1, T_accumulator ></type>
+ <name>emitter_type</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a63c6e2b55c8c3af083402bb7f5a66593</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::iterator</type>
+ <name>iterator</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>ab61e2d1fcaf903dffbb26b01800907fb</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>emitter_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>adcdcfa50d60e1832ce038a4a5554fce1</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::reverse_iterator</type>
+ <name>reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>ab0443049aa736d88770d0f534600b2bc</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list< slot_type ></type>
+ <name>slot_list_type</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a5fadeb350140d6aaf560b217e7e7c4b4</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot< T_return(T_arg1)></type>
+ <name>slot_type</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a310736e1415c2cf4578892ffff35915c</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal1</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>aba62d8d0b9591bcfd728f8ae8a22d600</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal1</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>ab3378dd754ffddb4760f2a3afb271dbe</anchor>
+ <arglist>(const signal1 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal1</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a85ec968e0b25ee9285f297da5416b2a4</anchor>
+ <arglist>(signal1 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>aac2ade0896bd4a982777d5dd6ac75888</anchor>
+ <arglist>(const slot_type &slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>ac69d2681c586b310d8c056a319bb65fe</anchor>
+ <arglist>(slot_type &&slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>affe595f8b70b4f43a21be7192c0cba42</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1) const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit_reverse</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a449fc940ae822c4b6ea9282b9b292015</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1) const</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor1< result_type, signal1, type_trait_take_t< T_arg1 > ></type>
+ <name>make_slot</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a87513117263fd39d5a5a86e0fb8b2a78</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a828907c11f5c18d9522e5d5139484620</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1) const</arglist>
+ </member>
+ <member kind="function">
+ <type>signal1 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a29cd06bf91f96f11c5f29237b8afbb71</anchor>
+ <arglist>(const signal1 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal1 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>ab817711d4bc93402d15e87b89a09c364</anchor>
+ <arglist>(signal1 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a7653b68e6a3b8445de91f89060bf2600</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal1.html</anchorfile>
+ <anchor>a7777660b21fef2a6941c7dff23964604</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>signal2< T_return, T_arg1, T_arg2, nil ></name>
+ <filename>classsigc_1_1signal2.html</filename>
+ <base>sigc::signal_base</base>
+ <member kind="typedef">
+ <type>slot_list_type::const_iterator</type>
+ <name>const_iterator</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>ad507bc5ea29adb2305f8fa91acbd30ee</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::const_reverse_iterator</type>
+ <name>const_reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>aacb8fe57ffe01dea5c5fb5af44634287</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>internal::signal_emit2< T_return, T_arg1, T_arg2, nil ></type>
+ <name>emitter_type</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>a01379d580d21de8bc8d0d2d62e6324ea</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::iterator</type>
+ <name>iterator</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>a658ba1c6468882c9b1d480be2bbaf55e</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>emitter_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>a55151695417c33540357ff524bfe2665</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::reverse_iterator</type>
+ <name>reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>a6710759bdeb8e626fc09d8c448e6613f</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list< slot_type ></type>
+ <name>slot_list_type</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>af31262f54dfb2a97540de9c4a1fc5726</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot< T_return(T_arg1, T_arg2)></type>
+ <name>slot_type</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>af7797ae10e76307f8d230588e760f119</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal2</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>a47aba9b19bc2bef0be7183022567e3ea</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal2</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>aa634515507f2ea4a35584e12e2dc92e7</anchor>
+ <arglist>(const signal2 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal2</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>a20c59f06175d4c48394c65035d2c3376</anchor>
+ <arglist>(signal2 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>aa686af4f961b098a23d4f7276437c2b0</anchor>
+ <arglist>(const slot_type &slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>ab89b1876c69ea40954b0af37e75a21b4</anchor>
+ <arglist>(slot_type &&slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>afd12e2a266a6399cc32e888d6f5e6f2f</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit_reverse</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>ad2d5f3169ba147de8d43fde9e93bac98</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor2< result_type, signal2, type_trait_take_t< T_arg1 >, type_trait_take_t< T_arg2 > ></type>
+ <name>make_slot</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>a844d15c61c83933575e7953b29365efa</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>ac8b73c0624273b8dae819255961ea6a3</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</arglist>
+ </member>
+ <member kind="function">
+ <type>signal2 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>abeb05d9a2b40882bad753fccad6522be</anchor>
+ <arglist>(const signal2 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal2 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>a5d3f71fb9ee8754c4640fb5bfb954151</anchor>
+ <arglist>(signal2 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>ac28b0205aa1e60cc5ce062d4d8545323</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>aa6be4804147afd56657abf5b4cf8ce3d</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>signal2< T_return, T_arg1, T_arg2, T_accumulator ></name>
+ <filename>classsigc_1_1signal2.html</filename>
+ <base>sigc::signal_base</base>
+ <member kind="typedef">
+ <type>slot_list_type::const_iterator</type>
+ <name>const_iterator</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>ad507bc5ea29adb2305f8fa91acbd30ee</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::const_reverse_iterator</type>
+ <name>const_reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>aacb8fe57ffe01dea5c5fb5af44634287</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>internal::signal_emit2< T_return, T_arg1, T_arg2, T_accumulator ></type>
+ <name>emitter_type</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>a01379d580d21de8bc8d0d2d62e6324ea</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::iterator</type>
+ <name>iterator</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>a658ba1c6468882c9b1d480be2bbaf55e</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>emitter_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>a55151695417c33540357ff524bfe2665</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::reverse_iterator</type>
+ <name>reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>a6710759bdeb8e626fc09d8c448e6613f</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list< slot_type ></type>
+ <name>slot_list_type</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>af31262f54dfb2a97540de9c4a1fc5726</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot< T_return(T_arg1, T_arg2)></type>
+ <name>slot_type</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>af7797ae10e76307f8d230588e760f119</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal2</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>a47aba9b19bc2bef0be7183022567e3ea</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal2</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>aa634515507f2ea4a35584e12e2dc92e7</anchor>
+ <arglist>(const signal2 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal2</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>a20c59f06175d4c48394c65035d2c3376</anchor>
+ <arglist>(signal2 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>aa686af4f961b098a23d4f7276437c2b0</anchor>
+ <arglist>(const slot_type &slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>ab89b1876c69ea40954b0af37e75a21b4</anchor>
+ <arglist>(slot_type &&slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>afd12e2a266a6399cc32e888d6f5e6f2f</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit_reverse</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>ad2d5f3169ba147de8d43fde9e93bac98</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor2< result_type, signal2, type_trait_take_t< T_arg1 >, type_trait_take_t< T_arg2 > ></type>
+ <name>make_slot</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>a844d15c61c83933575e7953b29365efa</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>ac8b73c0624273b8dae819255961ea6a3</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2) const</arglist>
+ </member>
+ <member kind="function">
+ <type>signal2 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>abeb05d9a2b40882bad753fccad6522be</anchor>
+ <arglist>(const signal2 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal2 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>a5d3f71fb9ee8754c4640fb5bfb954151</anchor>
+ <arglist>(signal2 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>ac28b0205aa1e60cc5ce062d4d8545323</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal2.html</anchorfile>
+ <anchor>aa6be4804147afd56657abf5b4cf8ce3d</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>signal3< T_return, T_arg1, T_arg2, T_arg3, nil ></name>
+ <filename>classsigc_1_1signal3.html</filename>
+ <base>sigc::signal_base</base>
+ <member kind="typedef">
+ <type>slot_list_type::const_iterator</type>
+ <name>const_iterator</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a60e1ef95f82cd8981d61576d1e3f8e94</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::const_reverse_iterator</type>
+ <name>const_reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a4ba3eb58c4c5ac2c25f49c48fd0af264</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>internal::signal_emit3< T_return, T_arg1, T_arg2, T_arg3, nil ></type>
+ <name>emitter_type</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>adf54ec96c5fb78d4c8b7fc032a1937ad</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::iterator</type>
+ <name>iterator</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a8029a48126a2018947a2b6680ddabe6b</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>emitter_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a57c79755fc4c4b04196a9bf6742a0cc6</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::reverse_iterator</type>
+ <name>reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>acc453f0d5fc7f277494b2d6e737f6f68</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list< slot_type ></type>
+ <name>slot_list_type</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a3bc0616e7ac933e702a889a2a84e92d4</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot< T_return(T_arg1, T_arg2, T_arg3)></type>
+ <name>slot_type</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>afe37478128b40fb4efedcd3c0eb05b6b</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal3</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a52731959f272612fd6abfe8850c5c8cf</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal3</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>afe2c4320927b403b011a2538317e6c70</anchor>
+ <arglist>(const signal3 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal3</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>acd69c2a1d993f0b8993f82998f76020d</anchor>
+ <arglist>(signal3 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a3eae0b3796b2736be847f33a5124aacd</anchor>
+ <arglist>(const slot_type &slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>ad71389c6d6ea60e745897579b3344d00</anchor>
+ <arglist>(slot_type &&slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a8592e22e3780f2cdf19a568a8a116bbb</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit_reverse</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a97ff4f22c97920a81e3f27aa5d39ba99</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor3< result_type, signal3, type_trait_take_t< T_arg1 >, type_trait_take_t< T_arg2 >, type_trait_take_t< T_arg3 > ></type>
+ <name>make_slot</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a332be8eb0ee22c11a2e1d140ca1bc2df</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>aa7ae5338d6a883a28c61ff202e43547f</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</arglist>
+ </member>
+ <member kind="function">
+ <type>signal3 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a0c398a25051e920bc4338f35b4bf7df6</anchor>
+ <arglist>(const signal3 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal3 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>abafd9fe17f2b9b18e25eb0293e9e8bfd</anchor>
+ <arglist>(signal3 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>ab9606b708078956a758b81503f956bee</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a742eb282312187bf8ee6992df1114781</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>signal3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></name>
+ <filename>classsigc_1_1signal3.html</filename>
+ <base>sigc::signal_base</base>
+ <member kind="typedef">
+ <type>slot_list_type::const_iterator</type>
+ <name>const_iterator</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a60e1ef95f82cd8981d61576d1e3f8e94</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::const_reverse_iterator</type>
+ <name>const_reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a4ba3eb58c4c5ac2c25f49c48fd0af264</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>internal::signal_emit3< T_return, T_arg1, T_arg2, T_arg3, T_accumulator ></type>
+ <name>emitter_type</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>adf54ec96c5fb78d4c8b7fc032a1937ad</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::iterator</type>
+ <name>iterator</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a8029a48126a2018947a2b6680ddabe6b</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>emitter_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a57c79755fc4c4b04196a9bf6742a0cc6</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::reverse_iterator</type>
+ <name>reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>acc453f0d5fc7f277494b2d6e737f6f68</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list< slot_type ></type>
+ <name>slot_list_type</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a3bc0616e7ac933e702a889a2a84e92d4</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot< T_return(T_arg1, T_arg2, T_arg3)></type>
+ <name>slot_type</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>afe37478128b40fb4efedcd3c0eb05b6b</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal3</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a52731959f272612fd6abfe8850c5c8cf</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal3</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>afe2c4320927b403b011a2538317e6c70</anchor>
+ <arglist>(const signal3 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal3</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>acd69c2a1d993f0b8993f82998f76020d</anchor>
+ <arglist>(signal3 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a3eae0b3796b2736be847f33a5124aacd</anchor>
+ <arglist>(const slot_type &slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>ad71389c6d6ea60e745897579b3344d00</anchor>
+ <arglist>(slot_type &&slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a8592e22e3780f2cdf19a568a8a116bbb</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit_reverse</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a97ff4f22c97920a81e3f27aa5d39ba99</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor3< result_type, signal3, type_trait_take_t< T_arg1 >, type_trait_take_t< T_arg2 >, type_trait_take_t< T_arg3 > ></type>
+ <name>make_slot</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a332be8eb0ee22c11a2e1d140ca1bc2df</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>aa7ae5338d6a883a28c61ff202e43547f</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3) const</arglist>
+ </member>
+ <member kind="function">
+ <type>signal3 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a0c398a25051e920bc4338f35b4bf7df6</anchor>
+ <arglist>(const signal3 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal3 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>abafd9fe17f2b9b18e25eb0293e9e8bfd</anchor>
+ <arglist>(signal3 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>ab9606b708078956a758b81503f956bee</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal3.html</anchorfile>
+ <anchor>a742eb282312187bf8ee6992df1114781</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></name>
+ <filename>classsigc_1_1signal4.html</filename>
+ <base>sigc::signal_base</base>
+ <member kind="typedef">
+ <type>slot_list_type::const_iterator</type>
+ <name>const_iterator</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a3d2626edc726047c04c8fe5b9824b958</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::const_reverse_iterator</type>
+ <name>const_reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a555ce030884fdf2bde788b75db01bedf</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>internal::signal_emit4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil ></type>
+ <name>emitter_type</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>acf3d1e6d6487c0ecc13ed3eab949eec7</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::iterator</type>
+ <name>iterator</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a31e8354263a3097bba9c63b8494143f0</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>emitter_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>af32418ba14001a63d28af08abb7407f0</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::reverse_iterator</type>
+ <name>reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a1395da7d3283b0166af135193a4047c8</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list< slot_type ></type>
+ <name>slot_list_type</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a0ad0f56a43825c6d77d36dd2f06ef828</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot< T_return(T_arg1, T_arg2, T_arg3, T_arg4)></type>
+ <name>slot_type</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>aa93452fe80399184444d094786be851c</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal4</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a2d469f516a9edac2b20d7f6cf46e821a</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal4</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a2d29b39c12c6c014ed7166190e9c8e22</anchor>
+ <arglist>(const signal4 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal4</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a2197974bac2b5e8e7b1c417580686e9e</anchor>
+ <arglist>(signal4 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a5fdb6df3cf74f5c96fb6319eef4d0a39</anchor>
+ <arglist>(const slot_type &slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a5c8d2d9c91a134650a52631d49ecdaac</anchor>
+ <arglist>(slot_type &&slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>aa7774ba75b5e2391a6fe2841f8b3b0ef</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit_reverse</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a0aaf27875cdb8a0ae381372d98871ae1</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor4< result_type, signal4, type_trait_take_t< T_arg1 >, type_trait_take_t< T_arg2 >, type_trait_take_t< T_arg3 >, type_trait_take_t< T_arg4 > ></type>
+ <name>make_slot</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>aebcf1389e689b8d43ff739df118482bc</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a8523a4d47c3a6469fcc50da9977afdb8</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</arglist>
+ </member>
+ <member kind="function">
+ <type>signal4 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a05908db9c09a9c513529cd8b2106f913</anchor>
+ <arglist>(const signal4 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal4 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>ab21da01af7c724bf0cf9df35ee9a70c1</anchor>
+ <arglist>(signal4 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>ae490f1a6802c40a4c3b12e1580520c88</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a35f2cebe3804d3e04d3253b7cc8d2a72</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>signal4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></name>
+ <filename>classsigc_1_1signal4.html</filename>
+ <base>sigc::signal_base</base>
+ <member kind="typedef">
+ <type>slot_list_type::const_iterator</type>
+ <name>const_iterator</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a3d2626edc726047c04c8fe5b9824b958</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::const_reverse_iterator</type>
+ <name>const_reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a555ce030884fdf2bde788b75db01bedf</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>internal::signal_emit4< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator ></type>
+ <name>emitter_type</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>acf3d1e6d6487c0ecc13ed3eab949eec7</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::iterator</type>
+ <name>iterator</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a31e8354263a3097bba9c63b8494143f0</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>emitter_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>af32418ba14001a63d28af08abb7407f0</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::reverse_iterator</type>
+ <name>reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a1395da7d3283b0166af135193a4047c8</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list< slot_type ></type>
+ <name>slot_list_type</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a0ad0f56a43825c6d77d36dd2f06ef828</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot< T_return(T_arg1, T_arg2, T_arg3, T_arg4)></type>
+ <name>slot_type</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>aa93452fe80399184444d094786be851c</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal4</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a2d469f516a9edac2b20d7f6cf46e821a</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal4</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a2d29b39c12c6c014ed7166190e9c8e22</anchor>
+ <arglist>(const signal4 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal4</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a2197974bac2b5e8e7b1c417580686e9e</anchor>
+ <arglist>(signal4 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a5fdb6df3cf74f5c96fb6319eef4d0a39</anchor>
+ <arglist>(const slot_type &slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a5c8d2d9c91a134650a52631d49ecdaac</anchor>
+ <arglist>(slot_type &&slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>aa7774ba75b5e2391a6fe2841f8b3b0ef</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit_reverse</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a0aaf27875cdb8a0ae381372d98871ae1</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor4< result_type, signal4, type_trait_take_t< T_arg1 >, type_trait_take_t< T_arg2 >, type_trait_take_t< T_arg3 >, type_trait_take_t< T_arg4 > ></type>
+ <name>make_slot</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>aebcf1389e689b8d43ff739df118482bc</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a8523a4d47c3a6469fcc50da9977afdb8</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4) const</arglist>
+ </member>
+ <member kind="function">
+ <type>signal4 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a05908db9c09a9c513529cd8b2106f913</anchor>
+ <arglist>(const signal4 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal4 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>ab21da01af7c724bf0cf9df35ee9a70c1</anchor>
+ <arglist>(signal4 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>ae490f1a6802c40a4c3b12e1580520c88</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal4.html</anchorfile>
+ <anchor>a35f2cebe3804d3e04d3253b7cc8d2a72</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></name>
+ <filename>classsigc_1_1signal5.html</filename>
+ <base>sigc::signal_base</base>
+ <member kind="typedef">
+ <type>slot_list_type::const_iterator</type>
+ <name>const_iterator</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a17e79eed46f178a12d2751eddcf85290</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::const_reverse_iterator</type>
+ <name>const_reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>ad5ba46907fe236e0cff806888696d569</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>internal::signal_emit5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil ></type>
+ <name>emitter_type</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a7d77e5fa748b024842bf92e28cf0f4ab</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::iterator</type>
+ <name>iterator</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>acee689b441305fcee098345729fc28f3</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>emitter_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>aceb959897dcf8e3c7209c283d4848b94</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::reverse_iterator</type>
+ <name>reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>ab684cb9920d0f7949f28c03d50b58275</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list< slot_type ></type>
+ <name>slot_list_type</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a4c79ab227fc3b31b990e925636f7788e</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)></type>
+ <name>slot_type</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>ae73737aad5d854c6466e8b13e7963b9e</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal5</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>af717d1a6fd8612da84dce33fe6640b7a</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal5</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a7885861b9cdbacbe2d58a13cd96ec265</anchor>
+ <arglist>(const signal5 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal5</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>af39141aeec9dc870dd28926202493de4</anchor>
+ <arglist>(signal5 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a057789cc27a920700e240f8f3d78dd65</anchor>
+ <arglist>(const slot_type &slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a05cfed3d3e29158424bc810168d78153</anchor>
+ <arglist>(slot_type &&slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a8772fef879632c4ff45e82b4b00b0157</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit_reverse</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>aa6d2e202263e3879f0d3949612d7fcdf</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor5< result_type, signal5, type_trait_take_t< T_arg1 >, type_trait_take_t< T_arg2 >, type_trait_take_t< T_arg3 >, type_trait_take_t< T_arg4 >, type_trait_take_t< T_arg5 > ></type>
+ <name>make_slot</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a7b01481c87d4ec9c03095e76cb502c24</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a7a5bb7b92f49e99354caf50bfef16907</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</arglist>
+ </member>
+ <member kind="function">
+ <type>signal5 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a2c3d9a6d8b499da389672f44f8044ce6</anchor>
+ <arglist>(const signal5 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal5 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a5c652f8e549a2c555b79db8e8a05f407</anchor>
+ <arglist>(signal5 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>ad6a4ae2a214d8710be6e36bb425587fc</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a32af276c9c56abbb0386f54262b40be5</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>signal5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></name>
+ <filename>classsigc_1_1signal5.html</filename>
+ <base>sigc::signal_base</base>
+ <member kind="typedef">
+ <type>slot_list_type::const_iterator</type>
+ <name>const_iterator</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a17e79eed46f178a12d2751eddcf85290</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::const_reverse_iterator</type>
+ <name>const_reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>ad5ba46907fe236e0cff806888696d569</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>internal::signal_emit5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator ></type>
+ <name>emitter_type</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a7d77e5fa748b024842bf92e28cf0f4ab</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::iterator</type>
+ <name>iterator</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>acee689b441305fcee098345729fc28f3</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>emitter_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>aceb959897dcf8e3c7209c283d4848b94</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::reverse_iterator</type>
+ <name>reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>ab684cb9920d0f7949f28c03d50b58275</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list< slot_type ></type>
+ <name>slot_list_type</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a4c79ab227fc3b31b990e925636f7788e</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)></type>
+ <name>slot_type</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>ae73737aad5d854c6466e8b13e7963b9e</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal5</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>af717d1a6fd8612da84dce33fe6640b7a</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal5</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a7885861b9cdbacbe2d58a13cd96ec265</anchor>
+ <arglist>(const signal5 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal5</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>af39141aeec9dc870dd28926202493de4</anchor>
+ <arglist>(signal5 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a057789cc27a920700e240f8f3d78dd65</anchor>
+ <arglist>(const slot_type &slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a05cfed3d3e29158424bc810168d78153</anchor>
+ <arglist>(slot_type &&slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a8772fef879632c4ff45e82b4b00b0157</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit_reverse</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>aa6d2e202263e3879f0d3949612d7fcdf</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor5< result_type, signal5, type_trait_take_t< T_arg1 >, type_trait_take_t< T_arg2 >, type_trait_take_t< T_arg3 >, type_trait_take_t< T_arg4 >, type_trait_take_t< T_arg5 > ></type>
+ <name>make_slot</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a7b01481c87d4ec9c03095e76cb502c24</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a7a5bb7b92f49e99354caf50bfef16907</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5) const</arglist>
+ </member>
+ <member kind="function">
+ <type>signal5 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a2c3d9a6d8b499da389672f44f8044ce6</anchor>
+ <arglist>(const signal5 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal5 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a5c652f8e549a2c555b79db8e8a05f407</anchor>
+ <arglist>(signal5 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>ad6a4ae2a214d8710be6e36bb425587fc</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal5.html</anchorfile>
+ <anchor>a32af276c9c56abbb0386f54262b40be5</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></name>
+ <filename>classsigc_1_1signal6.html</filename>
+ <base>sigc::signal_base</base>
+ <member kind="typedef">
+ <type>slot_list_type::const_iterator</type>
+ <name>const_iterator</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>ac88a9c4e9bab5ad04c66d3f5d3978f0f</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::const_reverse_iterator</type>
+ <name>const_reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>aff490e7f75a83aa2f324a859f9071a79</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>internal::signal_emit6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></type>
+ <name>emitter_type</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>acdd2683223e4701f58350152f32f4488</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::iterator</type>
+ <name>iterator</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a1acee11287974cdac1bc63c856e5331d</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>emitter_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a56f1acca230e676dae665d41a10acc8f</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::reverse_iterator</type>
+ <name>reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a79b741b3f0def8f52fc185ad50b60673</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list< slot_type ></type>
+ <name>slot_list_type</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a0e4fea9bd1ed35f9d60bbc26c4fae007</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)></type>
+ <name>slot_type</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>ac62cdf4db7dcd5e30975e51e978f03db</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal6</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>af7f529bbd9cf26d468ed18426b9b51ea</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal6</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a0244dde296bd892c590c86ced5281e3b</anchor>
+ <arglist>(const signal6 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal6</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>ab717ce413bda79e1de41944d0675a8ca</anchor>
+ <arglist>(signal6 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a66c302607cf4fb74f5d3352f9c394c9b</anchor>
+ <arglist>(const slot_type &slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a1754aa5a8959da0bb55e42864a8365af</anchor>
+ <arglist>(slot_type &&slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a6361a9230323e7c7e86e2c9e6c8fe21b</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit_reverse</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a2e8b355902f0646fb34b52b495123167</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor6< result_type, signal6, type_trait_take_t< T_arg1 >, type_trait_take_t< T_arg2 >, type_trait_take_t< T_arg3 >, type_trait_take_t< T_arg4 >, type_trait_take_t< T_arg5 >, type_trait_take_t< T_arg6 > ></type>
+ <name>make_slot</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a97ae4180e80ac60b564fec58d1732317</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>affec011fd6e9605f10e50fdd4db424d8</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</arglist>
+ </member>
+ <member kind="function">
+ <type>signal6 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>ad7a4ab249b17bffccbfe441aa1420dd9</anchor>
+ <arglist>(const signal6 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal6 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a012b9abce888e420e1b5b3f29aa98900</anchor>
+ <arglist>(signal6 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>af44115a7bfa4586fc5312259a1df9567</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>ac66109f683ae86898ae10109a80b28a4</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>signal6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></name>
+ <filename>classsigc_1_1signal6.html</filename>
+ <base>sigc::signal_base</base>
+ <member kind="typedef">
+ <type>slot_list_type::const_iterator</type>
+ <name>const_iterator</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>ac88a9c4e9bab5ad04c66d3f5d3978f0f</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::const_reverse_iterator</type>
+ <name>const_reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>aff490e7f75a83aa2f324a859f9071a79</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>internal::signal_emit6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator ></type>
+ <name>emitter_type</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>acdd2683223e4701f58350152f32f4488</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::iterator</type>
+ <name>iterator</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a1acee11287974cdac1bc63c856e5331d</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>emitter_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a56f1acca230e676dae665d41a10acc8f</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::reverse_iterator</type>
+ <name>reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a79b741b3f0def8f52fc185ad50b60673</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list< slot_type ></type>
+ <name>slot_list_type</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a0e4fea9bd1ed35f9d60bbc26c4fae007</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)></type>
+ <name>slot_type</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>ac62cdf4db7dcd5e30975e51e978f03db</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal6</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>af7f529bbd9cf26d468ed18426b9b51ea</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal6</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a0244dde296bd892c590c86ced5281e3b</anchor>
+ <arglist>(const signal6 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal6</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>ab717ce413bda79e1de41944d0675a8ca</anchor>
+ <arglist>(signal6 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a66c302607cf4fb74f5d3352f9c394c9b</anchor>
+ <arglist>(const slot_type &slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a1754aa5a8959da0bb55e42864a8365af</anchor>
+ <arglist>(slot_type &&slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a6361a9230323e7c7e86e2c9e6c8fe21b</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit_reverse</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a2e8b355902f0646fb34b52b495123167</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor6< result_type, signal6, type_trait_take_t< T_arg1 >, type_trait_take_t< T_arg2 >, type_trait_take_t< T_arg3 >, type_trait_take_t< T_arg4 >, type_trait_take_t< T_arg5 >, type_trait_take_t< T_arg6 > ></type>
+ <name>make_slot</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a97ae4180e80ac60b564fec58d1732317</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>affec011fd6e9605f10e50fdd4db424d8</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6) const</arglist>
+ </member>
+ <member kind="function">
+ <type>signal6 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>ad7a4ab249b17bffccbfe441aa1420dd9</anchor>
+ <arglist>(const signal6 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal6 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>a012b9abce888e420e1b5b3f29aa98900</anchor>
+ <arglist>(signal6 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>af44115a7bfa4586fc5312259a1df9567</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal6.html</anchorfile>
+ <anchor>ac66109f683ae86898ae10109a80b28a4</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>signal7< T_return, nil, nil, nil, nil, nil, nil, nil, nil ></name>
+ <filename>classsigc_1_1signal7.html</filename>
+ <base>sigc::signal_base</base>
+ <member kind="typedef">
+ <type>slot_list_type::const_iterator</type>
+ <name>const_iterator</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a6eef6225eba66a86dd32c3f3b79845f7</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::const_reverse_iterator</type>
+ <name>const_reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>ad1ba32ad7dae0c05a4012ada78077505</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>internal::signal_emit7< T_return, nil, nil, nil, nil, nil, nil, nil, nil ></type>
+ <name>emitter_type</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a7fa856e67a31c86538db7c289a6870e3</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::iterator</type>
+ <name>iterator</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>abc62e52cc684f917577a2fe3cd914d4a</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>emitter_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a5a75d73a254cf91a0f3ad1cd3545e29f</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::reverse_iterator</type>
+ <name>reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a59c9c9fee7a98528839df592241351a9</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list< slot_type ></type>
+ <name>slot_list_type</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a79686c2174ab01dc23394953955ff003</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot< T_return(nil, nil, nil, nil, nil, nil, nil)></type>
+ <name>slot_type</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a72ee8c51eea3d1ba99eb9b512dfccd81</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal7</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>ab6d54db53a164fb459fcb342d4b45ff0</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal7</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a12d6e064d0a5c2a8c09d60a64184a823</anchor>
+ <arglist>(const signal7 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal7</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a5a5893dd4f97d77b7945819f5ada2aee</anchor>
+ <arglist>(signal7 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>adc55ac9b0f935fd87a67904022e03cb2</anchor>
+ <arglist>(const slot_type &slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a5aed4bdb8d85c3d854f01410d2d9d3a4</anchor>
+ <arglist>(slot_type &&slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>aead3b0e97ed0bd95f870b1956bff83c2</anchor>
+ <arglist>(type_trait_take_t< nil > _A_a1, type_trait_take_t< nil > _A_a2, type_trait_take_t< nil > _A_a3, type_trait_take_t< nil > _A_a4, type_trait_take_t< nil > _A_a5, type_trait_take_t< nil > _A_a6, type_trait_take_t< nil > _A_a7) const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit_reverse</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a192581feb2dbcfc9c56692e72e91e9a8</anchor>
+ <arglist>(type_trait_take_t< nil > _A_a1, type_trait_take_t< nil > _A_a2, type_trait_take_t< nil > _A_a3, type_trait_take_t< nil > _A_a4, type_trait_take_t< nil > _A_a5, type_trait_take_t< nil > _A_a6, type_trait_take_t< nil > _A_a7) const</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor7< result_type, signal7, type_trait_take_t< nil >, type_trait_take_t< nil >, type_trait_take_t< nil >, type_trait_take_t< nil >, type_trait_take_t< nil >, type_trait_take_t< nil >, type_trait_take_t< nil > ></type>
+ <name>make_slot</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a3f468c8b6cc55d675c75d0184bd8e38a</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>ac6fd43215c8f19082402387359330071</anchor>
+ <arglist>(type_trait_take_t< nil > _A_a1, type_trait_take_t< nil > _A_a2, type_trait_take_t< nil > _A_a3, type_trait_take_t< nil > _A_a4, type_trait_take_t< nil > _A_a5, type_trait_take_t< nil > _A_a6, type_trait_take_t< nil > _A_a7) const</arglist>
+ </member>
+ <member kind="function">
+ <type>signal7 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>af8a93a4c8fb0b78fa6578e7dc95f5751</anchor>
+ <arglist>(const signal7 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal7 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>ac06938f5cb6ff60a1bd5eaa32c990eea</anchor>
+ <arglist>(signal7 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a68153d9079b4881352113079cd6216f7</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a42509108239296e424844df2cd330aca</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil ></name>
+ <filename>classsigc_1_1signal7.html</filename>
+ <base>sigc::signal_base</base>
+ <member kind="typedef">
+ <type>slot_list_type::const_iterator</type>
+ <name>const_iterator</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a6eef6225eba66a86dd32c3f3b79845f7</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::const_reverse_iterator</type>
+ <name>const_reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>ad1ba32ad7dae0c05a4012ada78077505</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>internal::signal_emit7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil ></type>
+ <name>emitter_type</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a7fa856e67a31c86538db7c289a6870e3</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::iterator</type>
+ <name>iterator</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>abc62e52cc684f917577a2fe3cd914d4a</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>emitter_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a5a75d73a254cf91a0f3ad1cd3545e29f</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::reverse_iterator</type>
+ <name>reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a59c9c9fee7a98528839df592241351a9</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list< slot_type ></type>
+ <name>slot_list_type</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a79686c2174ab01dc23394953955ff003</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)></type>
+ <name>slot_type</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a72ee8c51eea3d1ba99eb9b512dfccd81</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal7</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>ab6d54db53a164fb459fcb342d4b45ff0</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal7</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a12d6e064d0a5c2a8c09d60a64184a823</anchor>
+ <arglist>(const signal7 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal7</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a5a5893dd4f97d77b7945819f5ada2aee</anchor>
+ <arglist>(signal7 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>adc55ac9b0f935fd87a67904022e03cb2</anchor>
+ <arglist>(const slot_type &slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a5aed4bdb8d85c3d854f01410d2d9d3a4</anchor>
+ <arglist>(slot_type &&slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>aead3b0e97ed0bd95f870b1956bff83c2</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit_reverse</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a192581feb2dbcfc9c56692e72e91e9a8</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor7< result_type, signal7, type_trait_take_t< T_arg1 >, type_trait_take_t< T_arg2 >, type_trait_take_t< T_arg3 >, type_trait_take_t< T_arg4 >, type_trait_take_t< T_arg5 >, type_trait_take_t< T_arg6 >, type_trait_take_t< T_arg7 > ></type>
+ <name>make_slot</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a3f468c8b6cc55d675c75d0184bd8e38a</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>ac6fd43215c8f19082402387359330071</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</arglist>
+ </member>
+ <member kind="function">
+ <type>signal7 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>af8a93a4c8fb0b78fa6578e7dc95f5751</anchor>
+ <arglist>(const signal7 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal7 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>ac06938f5cb6ff60a1bd5eaa32c990eea</anchor>
+ <arglist>(signal7 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a68153d9079b4881352113079cd6216f7</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a42509108239296e424844df2cd330aca</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>signal7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></name>
+ <filename>classsigc_1_1signal7.html</filename>
+ <base>sigc::signal_base</base>
+ <member kind="typedef">
+ <type>slot_list_type::const_iterator</type>
+ <name>const_iterator</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a6eef6225eba66a86dd32c3f3b79845f7</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::const_reverse_iterator</type>
+ <name>const_reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>ad1ba32ad7dae0c05a4012ada78077505</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>internal::signal_emit7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator ></type>
+ <name>emitter_type</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a7fa856e67a31c86538db7c289a6870e3</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::iterator</type>
+ <name>iterator</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>abc62e52cc684f917577a2fe3cd914d4a</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>emitter_type::result_type</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a5a75d73a254cf91a0f3ad1cd3545e29f</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list_type::reverse_iterator</type>
+ <name>reverse_iterator</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a59c9c9fee7a98528839df592241351a9</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot_list< slot_type ></type>
+ <name>slot_list_type</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a79686c2174ab01dc23394953955ff003</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>slot< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)></type>
+ <name>slot_type</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a72ee8c51eea3d1ba99eb9b512dfccd81</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal7</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>ab6d54db53a164fb459fcb342d4b45ff0</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal7</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a12d6e064d0a5c2a8c09d60a64184a823</anchor>
+ <arglist>(const signal7 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>signal7</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a5a5893dd4f97d77b7945819f5ada2aee</anchor>
+ <arglist>(signal7 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>adc55ac9b0f935fd87a67904022e03cb2</anchor>
+ <arglist>(const slot_type &slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>iterator</type>
+ <name>connect</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a5aed4bdb8d85c3d854f01410d2d9d3a4</anchor>
+ <arglist>(slot_type &&slot_)</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>aead3b0e97ed0bd95f870b1956bff83c2</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>emit_reverse</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a192581feb2dbcfc9c56692e72e91e9a8</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor7< result_type, signal7, type_trait_take_t< T_arg1 >, type_trait_take_t< T_arg2 >, type_trait_take_t< T_arg3 >, type_trait_take_t< T_arg4 >, type_trait_take_t< T_arg5 >, type_trait_take_t< T_arg6 >, type_trait_take_t< T_arg7 > ></type>
+ <name>make_slot</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a3f468c8b6cc55d675c75d0184bd8e38a</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>result_type</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>ac6fd43215c8f19082402387359330071</anchor>
+ <arglist>(type_trait_take_t< T_arg1 > _A_a1, type_trait_take_t< T_arg2 > _A_a2, type_trait_take_t< T_arg3 > _A_a3, type_trait_take_t< T_arg4 > _A_a4, type_trait_take_t< T_arg5 > _A_a5, type_trait_take_t< T_arg6 > _A_a6, type_trait_take_t< T_arg7 > _A_a7) const</arglist>
+ </member>
+ <member kind="function">
+ <type>signal7 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>af8a93a4c8fb0b78fa6578e7dc95f5751</anchor>
+ <arglist>(const signal7 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>signal7 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>ac06938f5cb6ff60a1bd5eaa32c990eea</anchor>
+ <arglist>(signal7 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a68153d9079b4881352113079cd6216f7</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type>const slot_list_type</type>
+ <name>slots</name>
+ <anchorfile>classsigc_1_1signal7.html</anchorfile>
+ <anchor>a42509108239296e424844df2cd330aca</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>slot7< T_return, nil, nil, nil, nil, nil, nil, nil ></name>
+ <filename>classsigc_1_1slot7.html</filename>
+ <base>sigc::slot_base</base>
+ <member kind="typedef">
+ <type>type_trait_take_t< nil ></type>
+ <name>arg1_type_</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>a58edf93a837003d1a69fc77d39fc11a9</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>type_trait_take_t< nil ></type>
+ <name>arg2_type_</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>ad144d8ea3ecb891d358b5b1b969be7e2</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>type_trait_take_t< nil ></type>
+ <name>arg3_type_</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>af90cd5954008a84d6459d99de152a08c</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>type_trait_take_t< nil ></type>
+ <name>arg4_type_</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>af42bc9af248b7c2226d93230bd7b1024</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>type_trait_take_t< nil ></type>
+ <name>arg5_type_</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>ad6c1006a29f6fcb721bc39e8d6f82323</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>type_trait_take_t< nil ></type>
+ <name>arg6_type_</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>ae25a8a8663addfce52415a20725a3b3e</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>type_trait_take_t< nil ></type>
+ <name>arg7_type_</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>a2dc6c96b8d014fab9daea823188ca021</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>T_return</type>
+ <name>result_type</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>a06a374d3304636cb48fed29542dc851f</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot7</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>abf200ae4152fb26fc96a6863be3548b8</anchor>
+ <arglist>()</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot7</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>a6411349bb6f8d7151f41ae7772e61f6d</anchor>
+ <arglist>(const slot7 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot7</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>aa9b64dc6516b8a0d55f46e4737eaaf8b</anchor>
+ <arglist>(const T_functor &_A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type></type>
+ <name>slot7</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>a69a267bb61931f4ea039048d3221517c</anchor>
+ <arglist>(slot7 &&src)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_return</type>
+ <name>operator()</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>a28e18e1a9adc88a4758be7d2497fc88d</anchor>
+ <arglist>(arg1_type_ _A_a1, arg2_type_ _A_a2, arg3_type_ _A_a3, arg4_type_ _A_a4, arg5_type_ _A_a5, arg6_type_ _A_a6, arg7_type_ _A_a7) const</arglist>
+ </member>
+ <member kind="function">
+ <type>slot7 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>af6bf09a0b3c09245257af113e70269d2</anchor>
+ <arglist>(const slot7 &src)</arglist>
+ </member>
+ <member kind="function">
+ <type>slot7 &</type>
+ <name>operator=</name>
+ <anchorfile>classsigc_1_1slot7.html</anchorfile>
+ <anchor>a82b499c48909c51c4dad097885804638</anchor>
+ <arglist>(slot7 &&src)</arglist>
+ </member>
+ </compound>
+ <compound kind="class">
+ <name>volatile_limit_reference< T_obj ></name>
+ <filename>classsigc_1_1volatile__limit__reference.html</filename>
+ <member kind="function">
+ <type></type>
+ <name>volatile_limit_reference</name>
+ <anchorfile>classsigc_1_1volatile__limit__reference.html</anchorfile>
+ <anchor>acb3e6e1ecc628343f94faae718b58066</anchor>
+ <arglist>(T_obj &_A_target)</arglist>
+ </member>
+ <member kind="function">
+ <type>volatile T_obj &</type>
+ <name>invoke</name>
+ <anchorfile>classsigc_1_1volatile__limit__reference.html</anchorfile>
+ <anchor>a0157cc89d9db4032c7a8f9159ebaeff3</anchor>
+ <arglist>() const</arglist>
+ </member>
+ <member kind="function">
+ <type>const T_obj &</type>
+ <name>visit</name>
+ <anchorfile>classsigc_1_1volatile__limit__reference.html</anchorfile>
+ <anchor>a4d67fe2d9d27c326136a9e5ac13a1a75</anchor>
+ <arglist>() const</arglist>
+ </member>
+ </compound>
+ <compound kind="namespace">
+ <name>sigc</name>
+ <filename>namespacesigc.html</filename>
+ <class kind="struct">sigc::adaptor_base</class>
+ <class kind="struct">sigc::adaptor_functor</class>
+ <class kind="struct">sigc::adaptor_trait</class>
+ <class kind="struct">sigc::adaptor_trait< T_functor, false ></class>
+ <class kind="struct">sigc::adaptor_trait< T_functor, true ></class>
+ <class kind="struct">sigc::adapts</class>
+ <class kind="struct">sigc::bind_functor</class>
+ <class kind="struct">sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></class>
+ <class kind="struct">sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></class>
+ <class kind="struct">sigc::bind_return_functor</class>
+ <class kind="class">sigc::bound_argument</class>
+ <class kind="class">sigc::bound_argument< const_reference_wrapper< T_wrapped > ></class>
+ <class kind="class">sigc::bound_argument< reference_wrapper< T_wrapped > ></class>
+ <class kind="class">sigc::bound_argument< std::reference_wrapper< T_wrapped > ></class>
+ <class kind="class">sigc::bound_const_mem_functor0</class>
+ <class kind="class">sigc::bound_const_mem_functor1</class>
+ <class kind="class">sigc::bound_const_mem_functor2</class>
+ <class kind="class">sigc::bound_const_mem_functor3</class>
+ <class kind="class">sigc::bound_const_mem_functor4</class>
+ <class kind="class">sigc::bound_const_mem_functor5</class>
+ <class kind="class">sigc::bound_const_mem_functor6</class>
+ <class kind="class">sigc::bound_const_mem_functor7</class>
+ <class kind="class">sigc::bound_const_volatile_mem_functor0</class>
+ <class kind="class">sigc::bound_const_volatile_mem_functor1</class>
+ <class kind="class">sigc::bound_const_volatile_mem_functor2</class>
+ <class kind="class">sigc::bound_const_volatile_mem_functor3</class>
+ <class kind="class">sigc::bound_const_volatile_mem_functor4</class>
+ <class kind="class">sigc::bound_const_volatile_mem_functor5</class>
+ <class kind="class">sigc::bound_const_volatile_mem_functor6</class>
+ <class kind="class">sigc::bound_const_volatile_mem_functor7</class>
+ <class kind="class">sigc::bound_mem_functor0</class>
+ <class kind="class">sigc::bound_mem_functor1</class>
+ <class kind="class">sigc::bound_mem_functor2</class>
+ <class kind="class">sigc::bound_mem_functor3</class>
+ <class kind="class">sigc::bound_mem_functor4</class>
+ <class kind="class">sigc::bound_mem_functor5</class>
+ <class kind="class">sigc::bound_mem_functor6</class>
+ <class kind="class">sigc::bound_mem_functor7</class>
+ <class kind="class">sigc::bound_volatile_mem_functor0</class>
+ <class kind="class">sigc::bound_volatile_mem_functor1</class>
+ <class kind="class">sigc::bound_volatile_mem_functor2</class>
+ <class kind="class">sigc::bound_volatile_mem_functor3</class>
+ <class kind="class">sigc::bound_volatile_mem_functor4</class>
+ <class kind="class">sigc::bound_volatile_mem_functor5</class>
+ <class kind="class">sigc::bound_volatile_mem_functor6</class>
+ <class kind="class">sigc::bound_volatile_mem_functor7</class>
+ <class kind="class">sigc::can_deduce_result_type_with_decltype</class>
+ <class kind="struct">sigc::compose1_functor</class>
+ <class kind="struct">sigc::compose2_functor</class>
+ <class kind="struct">sigc::connection</class>
+ <class kind="class">sigc::const_limit_reference</class>
+ <class kind="class">sigc::const_limit_reference< T_type, true ></class>
+ <class kind="class">sigc::const_mem_functor0</class>
+ <class kind="class">sigc::const_mem_functor1</class>
+ <class kind="class">sigc::const_mem_functor2</class>
+ <class kind="class">sigc::const_mem_functor3</class>
+ <class kind="class">sigc::const_mem_functor4</class>
+ <class kind="class">sigc::const_mem_functor5</class>
+ <class kind="class">sigc::const_mem_functor6</class>
+ <class kind="class">sigc::const_mem_functor7</class>
+ <class kind="struct">sigc::const_reference_wrapper</class>
+ <class kind="class">sigc::const_volatile_limit_reference</class>
+ <class kind="class">sigc::const_volatile_limit_reference< T_type, true ></class>
+ <class kind="class">sigc::const_volatile_mem_functor0</class>
+ <class kind="class">sigc::const_volatile_mem_functor1</class>
+ <class kind="class">sigc::const_volatile_mem_functor2</class>
+ <class kind="class">sigc::const_volatile_mem_functor3</class>
+ <class kind="class">sigc::const_volatile_mem_functor4</class>
+ <class kind="class">sigc::const_volatile_mem_functor5</class>
+ <class kind="class">sigc::const_volatile_mem_functor6</class>
+ <class kind="class">sigc::const_volatile_mem_functor7</class>
+ <class kind="struct">sigc::deduce_result_type</class>
+ <class kind="struct">sigc::exception_catch_functor</class>
+ <class kind="struct">sigc::exception_catch_functor< T_functor, T_catcher, void ></class>
+ <class kind="struct">sigc::functor_base</class>
+ <class kind="struct">sigc::functor_trait</class>
+ <class kind="struct">sigc::hide_functor</class>
+ <class kind="struct">sigc::hide_functor< 0, T_functor ></class>
+ <class kind="struct">sigc::hide_functor<-1, T_functor ></class>
+ <class kind="class">sigc::limit_reference</class>
+ <class kind="class">sigc::limit_reference< T_type, true ></class>
+ <class kind="class">sigc::mem_functor0</class>
+ <class kind="class">sigc::mem_functor1</class>
+ <class kind="class">sigc::mem_functor2</class>
+ <class kind="class">sigc::mem_functor3</class>
+ <class kind="class">sigc::mem_functor4</class>
+ <class kind="class">sigc::mem_functor5</class>
+ <class kind="class">sigc::mem_functor6</class>
+ <class kind="class">sigc::mem_functor7</class>
+ <class kind="struct">sigc::nil</class>
+ <class kind="class">sigc::pointer_functor0</class>
+ <class kind="class">sigc::pointer_functor1</class>
+ <class kind="class">sigc::pointer_functor2</class>
+ <class kind="class">sigc::pointer_functor3</class>
+ <class kind="class">sigc::pointer_functor4</class>
+ <class kind="class">sigc::pointer_functor5</class>
+ <class kind="class">sigc::pointer_functor6</class>
+ <class kind="class">sigc::pointer_functor7</class>
+ <class kind="struct">sigc::reference_wrapper</class>
+ <class kind="struct">sigc::retype_functor</class>
+ <class kind="struct">sigc::retype_return_functor</class>
+ <class kind="struct">sigc::retype_return_functor< void, T_functor ></class>
+ <class kind="class">sigc::signal</class>
+ <class kind="class">sigc::signal0</class>
+ <class kind="class">sigc::signal1</class>
+ <class kind="class">sigc::signal2</class>
+ <class kind="class">sigc::signal3</class>
+ <class kind="class">sigc::signal4</class>
+ <class kind="class">sigc::signal5</class>
+ <class kind="class">sigc::signal6</class>
+ <class kind="class">sigc::signal7</class>
+ <class kind="class">sigc::signal< T_return()></class>
+ <class kind="class">sigc::signal< T_return(T_arg1)></class>
+ <class kind="class">sigc::signal< T_return(T_arg1, T_arg2)></class>
+ <class kind="class">sigc::signal< T_return(T_arg1, T_arg2, T_arg3)></class>
+ <class kind="class">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4)></class>
+ <class kind="class">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)></class>
+ <class kind="class">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)></class>
+ <class kind="class">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)></class>
+ <class kind="class">sigc::signal< T_return, nil, nil, nil, nil, nil, nil, nil ></class>
+ <class kind="class">sigc::signal< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></class>
+ <class kind="class">sigc::signal< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></class>
+ <class kind="class">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></class>
+ <class kind="class">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></class>
+ <class kind="class">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></class>
+ <class kind="class">sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></class>
+ <class kind="struct">sigc::signal_base</class>
+ <class kind="class">sigc::slot</class>
+ <class kind="class">sigc::slot0</class>
+ <class kind="class">sigc::slot1</class>
+ <class kind="class">sigc::slot2</class>
+ <class kind="class">sigc::slot3</class>
+ <class kind="class">sigc::slot4</class>
+ <class kind="class">sigc::slot5</class>
+ <class kind="class">sigc::slot6</class>
+ <class kind="class">sigc::slot7</class>
+ <class kind="class">sigc::slot< T_return(T_arg...)></class>
+ <class kind="class">sigc::slot< T_return, nil, nil, nil, nil, nil, nil, nil ></class>
+ <class kind="class">sigc::slot< T_return, T_arg1, nil, nil, nil, nil, nil, nil ></class>
+ <class kind="class">sigc::slot< T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil ></class>
+ <class kind="class">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil ></class>
+ <class kind="class">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil ></class>
+ <class kind="class">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil ></class>
+ <class kind="class">sigc::slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil ></class>
+ <class kind="class">sigc::slot_base</class>
+ <class kind="struct">sigc::slot_const_iterator</class>
+ <class kind="struct">sigc::slot_iterator</class>
+ <class kind="struct">sigc::slot_list</class>
+ <class kind="class">sigc::track_obj_functor1</class>
+ <class kind="class">sigc::track_obj_functor2</class>
+ <class kind="class">sigc::track_obj_functor3</class>
+ <class kind="class">sigc::track_obj_functor4</class>
+ <class kind="class">sigc::track_obj_functor5</class>
+ <class kind="class">sigc::track_obj_functor6</class>
+ <class kind="class">sigc::track_obj_functor7</class>
+ <class kind="struct">sigc::trackable</class>
+ <class kind="struct">sigc::type_trait</class>
+ <class kind="struct">sigc::type_trait< const T_type & ></class>
+ <class kind="struct">sigc::type_trait< T_type & ></class>
+ <class kind="struct">sigc::type_trait< T_type[N]></class>
+ <class kind="struct">sigc::type_trait< void ></class>
+ <class kind="struct">sigc::unwrap_reference</class>
+ <class kind="struct">sigc::unwrap_reference< const_reference_wrapper< T_type > ></class>
+ <class kind="struct">sigc::unwrap_reference< reference_wrapper< T_type > ></class>
+ <class kind="struct">sigc::unwrap_reference< std::reference_wrapper< T_type > ></class>
+ <class kind="struct">sigc::visitor</class>
+ <class kind="class">sigc::volatile_limit_reference</class>
+ <class kind="class">sigc::volatile_limit_reference< T_type, true ></class>
+ <class kind="class">sigc::volatile_mem_functor0</class>
+ <class kind="class">sigc::volatile_mem_functor1</class>
+ <class kind="class">sigc::volatile_mem_functor2</class>
+ <class kind="class">sigc::volatile_mem_functor3</class>
+ <class kind="class">sigc::volatile_mem_functor4</class>
+ <class kind="class">sigc::volatile_mem_functor5</class>
+ <class kind="class">sigc::volatile_mem_functor6</class>
+ <class kind="class">sigc::volatile_mem_functor7</class>
+ <member kind="typedef">
+ <type>typename deduce_result_type< T_functor, T_args... >::type</type>
+ <name>deduce_result_t</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ab7791439fb79592300826fe076a8e3d1</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>typename type_trait< T >::pass</type>
+ <name>type_trait_pass_t</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>aa2d13c7fc829cfec6e0f9d5092f2aa79</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="typedef">
+ <type>typename type_trait< T >::take</type>
+ <name>type_trait_take_t</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>aa0d56c61023af35c47b79db80b32fd2e</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type>bind_functor< I_location, T_functor, T_bound1 ></type>
+ <name>bind</name>
+ <anchorfile>group__bind.html</anchorfile>
+ <anchor>ga2f099bc6056b32f2a58134ba8537c6f4</anchor>
+ <arglist>(const T_functor &_A_func, T_bound1 _A_b1)</arglist>
+ </member>
+ <member kind="function">
+ <type>bind_functor<-1, T_functor, T_type1 ></type>
+ <name>bind</name>
+ <anchorfile>group__bind.html</anchorfile>
+ <anchor>ga211b3361bb1ae7484b2b276fd926b962</anchor>
+ <arglist>(const T_functor &_A_func, T_type1 _A_b1)</arglist>
+ </member>
+ <member kind="function">
+ <type>bind_functor<-1, T_functor, T_type1, T_type2 ></type>
+ <name>bind</name>
+ <anchorfile>group__bind.html</anchorfile>
+ <anchor>gaf1e076f0734addb8080f1cbcac602591</anchor>
+ <arglist>(const T_functor &_A_func, T_type1 _A_b1, T_type2 _A_b2)</arglist>
+ </member>
+ <member kind="function">
+ <type>bind_functor<-1, T_functor, T_type1, T_type2, T_type3 ></type>
+ <name>bind</name>
+ <anchorfile>group__bind.html</anchorfile>
+ <anchor>ga047061c9fa7d9dcde68c27cceed476a1</anchor>
+ <arglist>(const T_functor &_A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3)</arglist>
+ </member>
+ <member kind="function">
+ <type>bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4 ></type>
+ <name>bind</name>
+ <anchorfile>group__bind.html</anchorfile>
+ <anchor>ga8366abceb86ee653ec2ac50cef9fd16d</anchor>
+ <arglist>(const T_functor &_A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4)</arglist>
+ </member>
+ <member kind="function">
+ <type>bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5 ></type>
+ <name>bind</name>
+ <anchorfile>group__bind.html</anchorfile>
+ <anchor>ga7f163c830d7906906cf21ff0c5e0f17f</anchor>
+ <arglist>(const T_functor &_A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4, T_type5 _A_b5)</arglist>
+ </member>
+ <member kind="function">
+ <type>bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6 ></type>
+ <name>bind</name>
+ <anchorfile>group__bind.html</anchorfile>
+ <anchor>gac370f58b773f68c229c181f07e9b9e79</anchor>
+ <arglist>(const T_functor &_A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4, T_type5 _A_b5, T_type6 _A_b6)</arglist>
+ </member>
+ <member kind="function">
+ <type>bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 ></type>
+ <name>bind</name>
+ <anchorfile>group__bind.html</anchorfile>
+ <anchor>ga962b581ef0c17562bb3317783d3ffe7d</anchor>
+ <arglist>(const T_functor &_A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4, T_type5 _A_b5, T_type6 _A_b6, T_type7 _A_b7)</arglist>
+ </member>
+ <member kind="function">
+ <type>bind_return_functor< T_return, T_functor ></type>
+ <name>bind_return</name>
+ <anchorfile>group__bind.html</anchorfile>
+ <anchor>gaca1ae2466988d67d00a5f2cd16c8d90a</anchor>
+ <arglist>(const T_functor &_A_functor, T_return _A_ret_value)</arglist>
+ </member>
+ <member kind="function">
+ <type>compose1_functor< T_setter, T_getter ></type>
+ <name>compose</name>
+ <anchorfile>group__compose.html</anchorfile>
+ <anchor>ga34cf5da8f6323bfdc41bc7113d6ad20a</anchor>
+ <arglist>(const T_setter &_A_setter, const T_getter &_A_getter)</arglist>
+ </member>
+ <member kind="function">
+ <type>compose2_functor< T_setter, T_getter1, T_getter2 ></type>
+ <name>compose</name>
+ <anchorfile>group__compose.html</anchorfile>
+ <anchor>ga4abf2a45eb2307a3dc5d870c86b0450d</anchor>
+ <arglist>(const T_setter &_A_setter, const T_getter1 &_A_getter1, const T_getter2 &_A_getter2)</arglist>
+ </member>
+ <member kind="function">
+ <type>exception_catch_functor< T_functor, T_catcher ></type>
+ <name>exception_catch</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>a0ae3b8a1ba26920cee4d7d9df2c39ed9</anchor>
+ <arglist>(const T_functor &_A_func, const T_catcher &_A_catcher)</arglist>
+ </member>
+ <member kind="function">
+ <type>hide_functor< I_location, T_functor ></type>
+ <name>hide</name>
+ <anchorfile>group__hide.html</anchorfile>
+ <anchor>gaf2cefea3a99acd44f68121424103172d</anchor>
+ <arglist>(const T_functor &_A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>hide_functor<-1, T_functor ></type>
+ <name>hide</name>
+ <anchorfile>group__hide.html</anchorfile>
+ <anchor>gacbbacd3553268d85b95e3a85aefb67e5</anchor>
+ <arglist>(const T_functor &_A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_return_functor< void, T_functor ></type>
+ <name>hide_return</name>
+ <anchorfile>group__hide.html</anchorfile>
+ <anchor>gae4e6f5491471c12440f1c5d480726b98</anchor>
+ <arglist>(const T_functor &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gaeef6e55681664df29b31edec51ea034d</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)() const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gaeef6e55681664df29b31edec51ea034d</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)() const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gaeef6e55681664df29b31edec51ea034d</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)() volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gaeef6e55681664df29b31edec51ea034d</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)())</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga7de39a04dfc6d37b2d12a25cdccfbe95</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga7de39a04dfc6d37b2d12a25cdccfbe95</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga7de39a04dfc6d37b2d12a25cdccfbe95</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga7de39a04dfc6d37b2d12a25cdccfbe95</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gab1add5c927b51b935b4f2d40558079fa</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gab1add5c927b51b935b4f2d40558079fa</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gab1add5c927b51b935b4f2d40558079fa</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gab1add5c927b51b935b4f2d40558079fa</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga1f1aa3b60c0d2d8b2470bba0b2b36023</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga1f1aa3b60c0d2d8b2470bba0b2b36023</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga1f1aa3b60c0d2d8b2470bba0b2b36023</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga1f1aa3b60c0d2d8b2470bba0b2b36023</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga481ef34d8423d26e8ff0a1916cd295d5</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga481ef34d8423d26e8ff0a1916cd295d5</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga481ef34d8423d26e8ff0a1916cd295d5</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga481ef34d8423d26e8ff0a1916cd295d5</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga09fb13b1684ec7c092ffef695dbb261a</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga09fb13b1684ec7c092ffef695dbb261a</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga09fb13b1684ec7c092ffef695dbb261a</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga09fb13b1684ec7c092ffef695dbb261a</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga0d9b992d69123a524b6c70c458ad0d40</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga0d9b992d69123a524b6c70c458ad0d40</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga0d9b992d69123a524b6c70c458ad0d40</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga0d9b992d69123a524b6c70c458ad0d40</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga5dcdaf235baa50049e6088d246853037</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga5dcdaf235baa50049e6088d246853037</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga5dcdaf235baa50049e6088d246853037</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga5dcdaf235baa50049e6088d246853037</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga7f57ec0156d33b4aa98e259d2e2062db</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)() const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga7f57ec0156d33b4aa98e259d2e2062db</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)() const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga7f57ec0156d33b4aa98e259d2e2062db</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)() volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga7f57ec0156d33b4aa98e259d2e2062db</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)())</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga0df7af9f32990cc624c4bb60782b4f78</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga0df7af9f32990cc624c4bb60782b4f78</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga0df7af9f32990cc624c4bb60782b4f78</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga0df7af9f32990cc624c4bb60782b4f78</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga118b2610268701be95cdc6fddb7bab3b</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga118b2610268701be95cdc6fddb7bab3b</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga118b2610268701be95cdc6fddb7bab3b</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga118b2610268701be95cdc6fddb7bab3b</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gaeb6bd4518e0f0c524dba13a6cbb2e319</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gaeb6bd4518e0f0c524dba13a6cbb2e319</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gaeb6bd4518e0f0c524dba13a6cbb2e319</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gaeb6bd4518e0f0c524dba13a6cbb2e319</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga02c906c95895c58e39ee301bb1577994</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga02c906c95895c58e39ee301bb1577994</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga02c906c95895c58e39ee301bb1577994</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga02c906c95895c58e39ee301bb1577994</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gab138ae1a340be983166b69872826b37d</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gab138ae1a340be983166b69872826b37d</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gab138ae1a340be983166b69872826b37d</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gab138ae1a340be983166b69872826b37d</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga3e3841c4844715d2f2d832ed506f028f</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga3e3841c4844715d2f2d832ed506f028f</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga3e3841c4844715d2f2d832ed506f028f</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga3e3841c4844715d2f2d832ed506f028f</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gaea5a2ace2699b8d1ffe93585e335548d</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gaea5a2ace2699b8d1ffe93585e335548d</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gaea5a2ace2699b8d1ffe93585e335548d</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gaea5a2ace2699b8d1ffe93585e335548d</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</arglist>
+ </member>
+ <member kind="function">
+ <type>const_volatile_mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gadf6b6d22c503b439019f0a2e77352419</anchor>
+ <arglist>(T_return(T_obj::*_A_func)() const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>const_mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gadf6b6d22c503b439019f0a2e77352419</anchor>
+ <arglist>(T_return(T_obj::*_A_func)() const)</arglist>
+ </member>
+ <member kind="function">
+ <type>volatile_mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gadf6b6d22c503b439019f0a2e77352419</anchor>
+ <arglist>(T_return(T_obj::*_A_func)() volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gadf6b6d22c503b439019f0a2e77352419</anchor>
+ <arglist>(T_return(T_obj::*_A_func)())</arglist>
+ </member>
+ <member kind="function">
+ <type>const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gab661fef0f04e2e439912eee6989e9657</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>const_mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gab661fef0f04e2e439912eee6989e9657</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>volatile_mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gab661fef0f04e2e439912eee6989e9657</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gab661fef0f04e2e439912eee6989e9657</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1))</arglist>
+ </member>
+ <member kind="function">
+ <type>const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2))</arglist>
+ </member>
+ <member kind="function">
+ <type>const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gaa3778234963fa65d4f638856d91109d1</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gaa3778234963fa65d4f638856d91109d1</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gaa3778234963fa65d4f638856d91109d1</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gaa3778234963fa65d4f638856d91109d1</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3))</arglist>
+ </member>
+ <member kind="function">
+ <type>const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gadadd40aba6dadd0edbaac609dfae3938</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gadadd40aba6dadd0edbaac609dfae3938</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gadadd40aba6dadd0edbaac609dfae3938</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gadadd40aba6dadd0edbaac609dfae3938</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</arglist>
+ </member>
+ <member kind="function">
+ <type>const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gaa01df6c622d59cfd2d0d8aa3c04c36d1</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gaa01df6c622d59cfd2d0d8aa3c04c36d1</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gaa01df6c622d59cfd2d0d8aa3c04c36d1</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gaa01df6c622d59cfd2d0d8aa3c04c36d1</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</arglist>
+ </member>
+ <member kind="function">
+ <type>const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga9030b647c35e06c68342fee34e8fd320</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga9030b647c35e06c68342fee34e8fd320</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga9030b647c35e06c68342fee34e8fd320</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga9030b647c35e06c68342fee34e8fd320</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</arglist>
+ </member>
+ <member kind="function">
+ <type>const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga54e4bf947e8c93c56931b8e8f7ed0d2e</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga54e4bf947e8c93c56931b8e8f7ed0d2e</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga54e4bf947e8c93c56931b8e8f7ed0d2e</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga54e4bf947e8c93c56931b8e8f7ed0d2e</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun0</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gaf71277763f14050e2d270fcf3ea41dc9</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)() const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun0</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gaf71277763f14050e2d270fcf3ea41dc9</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)() const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun0</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gaf71277763f14050e2d270fcf3ea41dc9</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)() volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun0</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gaf71277763f14050e2d270fcf3ea41dc9</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)())</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun0</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gae03d0b73b85e85d2ad8bc43b19b855e3</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)() const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun0</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gae03d0b73b85e85d2ad8bc43b19b855e3</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)() const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun0</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gae03d0b73b85e85d2ad8bc43b19b855e3</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)() volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun0</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gae03d0b73b85e85d2ad8bc43b19b855e3</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)())</arglist>
+ </member>
+ <member kind="function">
+ <type>const_volatile_mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun0</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga765b35689a909fbc2a627be8256c5b1f</anchor>
+ <arglist>(T_return(T_obj::*_A_func)() const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>const_mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun0</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga765b35689a909fbc2a627be8256c5b1f</anchor>
+ <arglist>(T_return(T_obj::*_A_func)() const)</arglist>
+ </member>
+ <member kind="function">
+ <type>volatile_mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun0</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga765b35689a909fbc2a627be8256c5b1f</anchor>
+ <arglist>(T_return(T_obj::*_A_func)() volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun0</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga765b35689a909fbc2a627be8256c5b1f</anchor>
+ <arglist>(T_return(T_obj::*_A_func)())</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun1</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gaade596a4dacfd1429039525bb9f399d0</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun1</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gaade596a4dacfd1429039525bb9f399d0</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun1</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gaade596a4dacfd1429039525bb9f399d0</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun1</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gaade596a4dacfd1429039525bb9f399d0</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun1</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga3dd8d2ed97310dbf4fa394999f0be7b7</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun1</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga3dd8d2ed97310dbf4fa394999f0be7b7</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun1</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga3dd8d2ed97310dbf4fa394999f0be7b7</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun1</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga3dd8d2ed97310dbf4fa394999f0be7b7</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1))</arglist>
+ </member>
+ <member kind="function">
+ <type>const_volatile_mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun1</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gae0bebf0d8a2d36d93746c23d9eea668d</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>const_mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun1</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gae0bebf0d8a2d36d93746c23d9eea668d</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>volatile_mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun1</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gae0bebf0d8a2d36d93746c23d9eea668d</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun1</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gae0bebf0d8a2d36d93746c23d9eea668d</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun2</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gaee7652f1a0625df50af50e28b5e2423e</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun2</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gaee7652f1a0625df50af50e28b5e2423e</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun2</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gaee7652f1a0625df50af50e28b5e2423e</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun2</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gaee7652f1a0625df50af50e28b5e2423e</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun2</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga184da4166c8b5409dc4b98d7bc16dff8</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun2</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga184da4166c8b5409dc4b98d7bc16dff8</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun2</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga184da4166c8b5409dc4b98d7bc16dff8</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun2</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga184da4166c8b5409dc4b98d7bc16dff8</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2))</arglist>
+ </member>
+ <member kind="function">
+ <type>const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun2</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gab76f41aeada332b353b6fe2e96008831</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun2</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gab76f41aeada332b353b6fe2e96008831</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun2</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gab76f41aeada332b353b6fe2e96008831</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun2</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gab76f41aeada332b353b6fe2e96008831</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun3</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga14e07df139b5cb6897e671c50fc33cde</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun3</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga14e07df139b5cb6897e671c50fc33cde</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun3</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga14e07df139b5cb6897e671c50fc33cde</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun3</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga14e07df139b5cb6897e671c50fc33cde</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun3</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga4f2fdbf02e8cac9492326a4a8ffdd012</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun3</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga4f2fdbf02e8cac9492326a4a8ffdd012</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun3</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga4f2fdbf02e8cac9492326a4a8ffdd012</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun3</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga4f2fdbf02e8cac9492326a4a8ffdd012</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3))</arglist>
+ </member>
+ <member kind="function">
+ <type>const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun3</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga2379e0d689fe4a99c7c669fc29817457</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun3</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga2379e0d689fe4a99c7c669fc29817457</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun3</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga2379e0d689fe4a99c7c669fc29817457</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun3</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga2379e0d689fe4a99c7c669fc29817457</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun4</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga86da5637e2735480d525ffa930e7e21a</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun4</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga86da5637e2735480d525ffa930e7e21a</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun4</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga86da5637e2735480d525ffa930e7e21a</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun4</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga86da5637e2735480d525ffa930e7e21a</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun4</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga94a2525ef116e16598b81b853544a170</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun4</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga94a2525ef116e16598b81b853544a170</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun4</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga94a2525ef116e16598b81b853544a170</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun4</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga94a2525ef116e16598b81b853544a170</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</arglist>
+ </member>
+ <member kind="function">
+ <type>const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun4</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga1bedd04f76ad3e21f614912562e95d83</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun4</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga1bedd04f76ad3e21f614912562e95d83</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun4</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga1bedd04f76ad3e21f614912562e95d83</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun4</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga1bedd04f76ad3e21f614912562e95d83</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun5</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga5c2ca9cef8c857935a59133a73ef61f2</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun5</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga5c2ca9cef8c857935a59133a73ef61f2</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun5</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga5c2ca9cef8c857935a59133a73ef61f2</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun5</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga5c2ca9cef8c857935a59133a73ef61f2</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun5</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gaf060fe3a2be4ff7c0f50aef54b4dc8bf</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun5</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gaf060fe3a2be4ff7c0f50aef54b4dc8bf</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun5</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gaf060fe3a2be4ff7c0f50aef54b4dc8bf</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun5</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gaf060fe3a2be4ff7c0f50aef54b4dc8bf</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</arglist>
+ </member>
+ <member kind="function">
+ <type>const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun5</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga3ef4bb904a751d29e2b6803ef81f72fa</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun5</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga3ef4bb904a751d29e2b6803ef81f72fa</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun5</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga3ef4bb904a751d29e2b6803ef81f72fa</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun5</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga3ef4bb904a751d29e2b6803ef81f72fa</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun6</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga947f4410e62a2996023177e490c882b7</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun6</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga947f4410e62a2996023177e490c882b7</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun6</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga947f4410e62a2996023177e490c882b7</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun6</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga947f4410e62a2996023177e490c882b7</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun6</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gac0a6242da9bf96642f25c1363dfef383</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun6</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gac0a6242da9bf96642f25c1363dfef383</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun6</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>gac0a6242da9bf96642f25c1363dfef383</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun6</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gac0a6242da9bf96642f25c1363dfef383</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</arglist>
+ </member>
+ <member kind="function">
+ <type>const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun6</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga34ace98fbbd18cb635795639d0f22678</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun6</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga34ace98fbbd18cb635795639d0f22678</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun6</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga34ace98fbbd18cb635795639d0f22678</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun6</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga34ace98fbbd18cb635795639d0f22678</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun7</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga1f704e475da2aad1717e059c264c1436</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun7</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga1f704e475da2aad1717e059c264c1436</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun7</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga1f704e475da2aad1717e059c264c1436</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun7</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga1f704e475da2aad1717e059c264c1436</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun7</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga9899534bc8eb78c227d895b396710091</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun7</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga9899534bc8eb78c227d895b396710091</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun7</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga9899534bc8eb78c227d895b396710091</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun7</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga9899534bc8eb78c227d895b396710091</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</arglist>
+ </member>
+ <member kind="function">
+ <type>const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun7</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga3d174b01bf94dbda3aea58c25c2b3322</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun7</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga3d174b01bf94dbda3aea58c25c2b3322</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)</arglist>
+ </member>
+ <member kind="function">
+ <type>volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun7</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>ga3d174b01bf94dbda3aea58c25c2b3322</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun7</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga3d174b01bf94dbda3aea58c25c2b3322</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor0< T_return ></type>
+ <name>ptr_fun</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>ga9c80de72f656fb05e81fda622dddc863</anchor>
+ <arglist>(T_return(*_A_func)())</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor1< T_arg1, T_return ></type>
+ <name>ptr_fun</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>ga9b1c3b4ecb24056f5bd38fc6a87f9ad1</anchor>
+ <arglist>(T_return(*_A_func)(T_arg1))</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor2< T_arg1, T_arg2, T_return ></type>
+ <name>ptr_fun</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>ga9c0db14ab1a864b2bad70000325d94c8</anchor>
+ <arglist>(T_return(*_A_func)(T_arg1, T_arg2))</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor3< T_arg1, T_arg2, T_arg3, T_return ></type>
+ <name>ptr_fun</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>ga1cd2254135f3afcfc5ce34e73cf2f48b</anchor>
+ <arglist>(T_return(*_A_func)(T_arg1, T_arg2, T_arg3))</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return ></type>
+ <name>ptr_fun</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>gaa23ae1abf223560bcac001b86d3cc484</anchor>
+ <arglist>(T_return(*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return ></type>
+ <name>ptr_fun</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>gafd3087df10b981325953c93e914d451e</anchor>
+ <arglist>(T_return(*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return ></type>
+ <name>ptr_fun</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>ga0f4d43c3aace56cc5ce0f38886b9ace6</anchor>
+ <arglist>(T_return(*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return ></type>
+ <name>ptr_fun</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>ga65221432dda1b020b73349627762da70</anchor>
+ <arglist>(T_return(*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor0< T_return ></type>
+ <name>ptr_fun0</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>gaad8dffc194a4e4dfa0935ce49d43cd5c</anchor>
+ <arglist>(T_return(*_A_func)())</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor1< T_arg1, T_return ></type>
+ <name>ptr_fun1</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>ga9b1b8e8f5555d6be4ba41be3fb82c94e</anchor>
+ <arglist>(T_return(*_A_func)(T_arg1))</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor2< T_arg1, T_arg2, T_return ></type>
+ <name>ptr_fun2</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>ga0244165b83e41a30b2dfb9523afad446</anchor>
+ <arglist>(T_return(*_A_func)(T_arg1, T_arg2))</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor3< T_arg1, T_arg2, T_arg3, T_return ></type>
+ <name>ptr_fun3</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>ga749e83ea85926d5ad6994d775f98de8d</anchor>
+ <arglist>(T_return(*_A_func)(T_arg1, T_arg2, T_arg3))</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return ></type>
+ <name>ptr_fun4</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>gac6fa01189c786e778d943a2ee60896a4</anchor>
+ <arglist>(T_return(*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return ></type>
+ <name>ptr_fun5</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>ga37ae059caefef68e441d3dd7d5b11cce</anchor>
+ <arglist>(T_return(*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return ></type>
+ <name>ptr_fun6</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>ga8cdf17b7ec15b260f5147e1171dd5299</anchor>
+ <arglist>(T_return(*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return ></type>
+ <name>ptr_fun7</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>ga82e53ab558dae814c16a09edb53617bb</anchor>
+ <arglist>(T_return(*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</arglist>
+ </member>
+ <member kind="function">
+ <type>const_reference_wrapper< T_type ></type>
+ <name>ref</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>a670882bd3fa5890b464871ac515aaba9</anchor>
+ <arglist>(const T_type &v)</arglist>
+ </member>
+ <member kind="function">
+ <type>reference_wrapper< T_type ></type>
+ <name>ref</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>a48e982c74c057b5630246ba436524041</anchor>
+ <arglist>(T_type &v)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_mem_functor0< T_return, T_obj > ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga31061f134d93297fd0b4f2d56efafbe3</anchor>
+ <arglist>(const bound_const_mem_functor0< T_return, T_obj > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_mem_functor1< T_return, T_obj, T_arg1 >, T_arg1 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga63ead6c4883a6553446594e6027dc96c</anchor>
+ <arglist>(const bound_const_mem_functor1< T_return, T_obj, T_arg1 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga415bd3f44f1785ce30452a4ca8e46dd0</anchor>
+ <arglist>(const bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga6f86026b9959cdd62287b29407c71e97</anchor>
+ <arglist>(const bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga8fbc58cc94f7f4a46c1557091974a278</anchor>
+ <arglist>(const bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga1d0d963fa703a6f85b8002c3a405c00a</anchor>
+ <arglist>(const bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga39ba6af86d75de1535e4fa8af1e6081b</anchor>
+ <arglist>(const bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga02a44f2ea2386f8e4fa41cb582c2008d</anchor>
+ <arglist>(const bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_volatile_mem_functor0< T_return, T_obj > ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gade9ed42b368ea6eee6d42c8116cd28dd</anchor>
+ <arglist>(const bound_const_volatile_mem_functor0< T_return, T_obj > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 >, T_arg1 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gaab22de279058fd53d5ef720ad3932b56</anchor>
+ <arglist>(const bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga42f7c6ae10273b6577909f89bd76dc1f</anchor>
+ <arglist>(const bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga1b2477c6ed3347fae35c66f25977f9dc</anchor>
+ <arglist>(const bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gad73b9445fab1544d7550db964426520d</anchor>
+ <arglist>(const bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gacbb4a1e1c3447205bf507d6912847015</anchor>
+ <arglist>(const bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gace1ef4f9ca35373adaad3c29db2b918f</anchor>
+ <arglist>(const bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga1ec0f19b59050f8f01c8969835b3c742</anchor>
+ <arglist>(const bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_mem_functor0< T_return, T_obj > ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gaebe9c150af92e230257bbbdb728e5a07</anchor>
+ <arglist>(const bound_mem_functor0< T_return, T_obj > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_mem_functor1< T_return, T_obj, T_arg1 >, T_arg1 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga971017d74a880ee10555ebd32483d188</anchor>
+ <arglist>(const bound_mem_functor1< T_return, T_obj, T_arg1 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gaddf62506fc01f1cdfcadef27e47f9b59</anchor>
+ <arglist>(const bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gad916eb17d984df3b7da9b7d3d041168a</anchor>
+ <arglist>(const bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga8362fa71a99b71b843205e0482b281fc</anchor>
+ <arglist>(const bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga9c139b3254f5020de44a73c7dd795819</anchor>
+ <arglist>(const bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga12e152b4340f83bd1f6cec92771fa82a</anchor>
+ <arglist>(const bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gadda8029b543d9b657f01e6ba9a9ef8fd</anchor>
+ <arglist>(const bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_volatile_mem_functor0< T_return, T_obj > ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gadc01bb77132048902ec8965d012edcd3</anchor>
+ <arglist>(const bound_volatile_mem_functor0< T_return, T_obj > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_volatile_mem_functor1< T_return, T_obj, T_arg1 >, T_arg1 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga45b921820c277072b6f7e856ddbcfca1</anchor>
+ <arglist>(const bound_volatile_mem_functor1< T_return, T_obj, T_arg1 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gaf420d79b4077b848ef1aef4b68810d6e</anchor>
+ <arglist>(const bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga899ae79da0e918ad9fc8f2c8e8066218</anchor>
+ <arglist>(const bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga8540037bfd4da57495b60dd9487c6d0b</anchor>
+ <arglist>(const bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga31ace8220cbb70b8e7f545ee4c1b6610</anchor>
+ <arglist>(const bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga9f45f05c95abc9d20ae9d39589f5d72e</anchor>
+ <arglist>(const bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga17e8761db2fafa2d3a92d19d8ce47511</anchor>
+ <arglist>(const bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_mem_functor0< T_return, T_obj > ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga0688ca8eb3ee82e191563ba7f81366b2</anchor>
+ <arglist>(const const_mem_functor0< T_return, T_obj > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_mem_functor1< T_return, T_obj, T_arg1 >, T_arg1 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gae035134414ed79a187a6b41a115a3759</anchor>
+ <arglist>(const const_mem_functor1< T_return, T_obj, T_arg1 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga8e9ee582f601451f3aa7c3d37d03b952</anchor>
+ <arglist>(const const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga81e06b857f7a44b0589125e28535f87f</anchor>
+ <arglist>(const const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga411bdd3476f80d627c50d47149862ec2</anchor>
+ <arglist>(const const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga995053759ee8ee89663f9625a4aaf596</anchor>
+ <arglist>(const const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga851188153c54bb1eb8fee425f9796981</anchor>
+ <arglist>(const const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gaa951debcabd066f8c3479617aaa9689e</anchor>
+ <arglist>(const const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_volatile_mem_functor0< T_return, T_obj > ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga312fca59eb8b4ca0e078b1cf7f407212</anchor>
+ <arglist>(const const_volatile_mem_functor0< T_return, T_obj > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_volatile_mem_functor1< T_return, T_obj, T_arg1 >, T_arg1 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga84f4247ab4cc559aed835ccd943fab70</anchor>
+ <arglist>(const const_volatile_mem_functor1< T_return, T_obj, T_arg1 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga271911579dfbac317a53f62f0773e420</anchor>
+ <arglist>(const const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga97b4f14b5a7991eba60b635871d6a7f9</anchor>
+ <arglist>(const const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga4e9179cc61db0069db209bc7632b3dee</anchor>
+ <arglist>(const const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga637af7b3e60f5657dcd62e350ec76675</anchor>
+ <arglist>(const const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga17ceafe96cdf3bd37ccd401f413f8748</anchor>
+ <arglist>(const const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga75578233ce4f47c5f610569a5ffe84cc</anchor>
+ <arglist>(const const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< mem_functor0< T_return, T_obj > ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gabb08dd87f3ec392536b656b6b3e959a0</anchor>
+ <arglist>(const mem_functor0< T_return, T_obj > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< mem_functor1< T_return, T_obj, T_arg1 >, T_arg1 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga5a2600190453d4eb11c14f99973044bc</anchor>
+ <arglist>(const mem_functor1< T_return, T_obj, T_arg1 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< mem_functor2< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga7df338186f09b1c89c2840f6744362e9</anchor>
+ <arglist>(const mem_functor2< T_return, T_obj, T_arg1, T_arg2 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gae2d9d2e91b2f8d256e4ad8da1c3c59e0</anchor>
+ <arglist>(const mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga70e615639e07e90a997a378cf877b106</anchor>
+ <arglist>(const mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gad225dee1d71c68d0ee71f3f0fedcfc1b</anchor>
+ <arglist>(const mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga9c08fe50076854f15c923ab4183aed0f</anchor>
+ <arglist>(const mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga3fbd72b71a4ea4fafa487b5932acd797</anchor>
+ <arglist>(const mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< pointer_functor0< T_return > ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga23978c94d9d3c934803898c3bf48ff7d</anchor>
+ <arglist>(const pointer_functor0< T_return > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< pointer_functor1< T_arg1, T_return >, T_arg1 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga75cc92c15faf06d5293ff34179f21899</anchor>
+ <arglist>(const pointer_functor1< T_arg1, T_return > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< pointer_functor2< T_arg1, T_arg2, T_return >, T_arg1, T_arg2 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga0d67e207b3d753ab71b3801981cfeff3</anchor>
+ <arglist>(const pointer_functor2< T_arg1, T_arg2, T_return > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< pointer_functor3< T_arg1, T_arg2, T_arg3, T_return >, T_arg1, T_arg2, T_arg3 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gaa5dfa926e3bfc7b82e0d14e4d9c9ff32</anchor>
+ <arglist>(const pointer_functor3< T_arg1, T_arg2, T_arg3, T_return > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return >, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gade02a3d76cf35465acfa39d4e03a40d5</anchor>
+ <arglist>(const pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga45fa726d6497c6b0994444fd2569581c</anchor>
+ <arglist>(const pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga24e30de09c3784220829f52bb068b8c0</anchor>
+ <arglist>(const pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga09db0b458651a7fcd985e5dd4e50caa0</anchor>
+ <arglist>(const pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga8b98eeb2a61b5b1f84dcd1d20fe666f1</anchor>
+ <arglist>(const slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< volatile_mem_functor0< T_return, T_obj > ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga53d620659c82cbb84da3812ac874f4b7</anchor>
+ <arglist>(const volatile_mem_functor0< T_return, T_obj > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< volatile_mem_functor1< T_return, T_obj, T_arg1 >, T_arg1 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga6d7f05b930056183bc7537447c80e59b</anchor>
+ <arglist>(const volatile_mem_functor1< T_return, T_obj, T_arg1 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga5b65e9a9794300c40b1577302e006fbd</anchor>
+ <arglist>(const volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga55236721b80a72f40453d1b939316635</anchor>
+ <arglist>(const volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga05d2c3c043bed420ba8ba6f40f42f692</anchor>
+ <arglist>(const volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga42be2d2fbf03fbaba1ad7d8cbbb8bce4</anchor>
+ <arglist>(const volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga255fac4b456d69d033b327b1d533f054</anchor>
+ <arglist>(const volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga37a057f88e6ffbb8d4172d6446116796</anchor>
+ <arglist>(const volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_return_functor< T_return, T_functor ></type>
+ <name>retype_return</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga23a8cdbc12c57fbef0866b5c51d71588</anchor>
+ <arglist>(const T_functor &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>track_obj_functor1< T_functor, T_obj1 ></type>
+ <name>track_obj</name>
+ <anchorfile>group__track__obj.html</anchorfile>
+ <anchor>ga8fd1ab36d123ff83dd4cd8dc58bb28e2</anchor>
+ <arglist>(const T_functor &_A_func, const T_obj1 &_A_obj1)</arglist>
+ </member>
+ <member kind="function">
+ <type>track_obj_functor2< T_functor, T_obj1, T_obj2 ></type>
+ <name>track_obj</name>
+ <anchorfile>group__track__obj.html</anchorfile>
+ <anchor>ga60842510c2387ec49c43149d94fb1b72</anchor>
+ <arglist>(const T_functor &_A_func, const T_obj1 &_A_obj1, const T_obj2 &_A_obj2)</arglist>
+ </member>
+ <member kind="function">
+ <type>track_obj_functor3< T_functor, T_obj1, T_obj2, T_obj3 ></type>
+ <name>track_obj</name>
+ <anchorfile>group__track__obj.html</anchorfile>
+ <anchor>ga52b11304cb05441237a8dcc651cb724e</anchor>
+ <arglist>(const T_functor &_A_func, const T_obj1 &_A_obj1, const T_obj2 &_A_obj2, const T_obj3 &_A_obj3)</arglist>
+ </member>
+ <member kind="function">
+ <type>track_obj_functor4< T_functor, T_obj1, T_obj2, T_obj3, T_obj4 ></type>
+ <name>track_obj</name>
+ <anchorfile>group__track__obj.html</anchorfile>
+ <anchor>gaea44f2388c18ca8508818ff6b7756216</anchor>
+ <arglist>(const T_functor &_A_func, const T_obj1 &_A_obj1, const T_obj2 &_A_obj2, const T_obj3 &_A_obj3, const T_obj4 &_A_obj4)</arglist>
+ </member>
+ <member kind="function">
+ <type>track_obj_functor5< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5 ></type>
+ <name>track_obj</name>
+ <anchorfile>group__track__obj.html</anchorfile>
+ <anchor>ga337dc48ba1e394f572d5d914b83f57a0</anchor>
+ <arglist>(const T_functor &_A_func, const T_obj1 &_A_obj1, const T_obj2 &_A_obj2, const T_obj3 &_A_obj3, const T_obj4 &_A_obj4, const T_obj5 &_A_obj5)</arglist>
+ </member>
+ <member kind="function">
+ <type>track_obj_functor6< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6 ></type>
+ <name>track_obj</name>
+ <anchorfile>group__track__obj.html</anchorfile>
+ <anchor>ga0304ca1269ed352fcc1c81324062302e</anchor>
+ <arglist>(const T_functor &_A_func, const T_obj1 &_A_obj1, const T_obj2 &_A_obj2, const T_obj3 &_A_obj3, const T_obj4 &_A_obj4, const T_obj5 &_A_obj5, const T_obj6 &_A_obj6)</arglist>
+ </member>
+ <member kind="function">
+ <type>track_obj_functor7< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6, T_obj7 ></type>
+ <name>track_obj</name>
+ <anchorfile>group__track__obj.html</anchorfile>
+ <anchor>ga5ea3e9f52643d7ab1bcfa4f419e7d38f</anchor>
+ <arglist>(const T_functor &_A_func, const T_obj1 &_A_obj1, const T_obj2 &_A_obj2, const T_obj3 &_A_obj3, const T_obj4 &_A_obj4, const T_obj5 &_A_obj5, const T_obj6 &_A_obj6, const T_obj7 &_A_obj7)</arglist>
+ </member>
+ <member kind="function">
+ <type>const T_type &</type>
+ <name>unwrap</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>a2f758c77e8743093f938d0c5dbf06778</anchor>
+ <arglist>(const const_reference_wrapper< T_type > &v)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_type &</type>
+ <name>unwrap</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>a3b5529822bdaf60f07456633e0f40282</anchor>
+ <arglist>(const reference_wrapper< T_type > &v)</arglist>
+ </member>
+ <member kind="function">
+ <type>T_type &</type>
+ <name>unwrap</name>
+ <anchorfile>namespacesigc.html</anchorfile>
+ <anchor>a3256789f3d3bb134471d7cf8fcf4d91a</anchor>
+ <arglist>(const std::reference_wrapper< T_type > &v)</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>visit_each</name>
+ <anchorfile>group__sigcfunctors.html</anchorfile>
+ <anchor>ga64cb7832acc1e58efb5ffe0b4f5e9404</anchor>
+ <arglist>(const T_action &_A_action, const T_functor &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>visit_each_type</name>
+ <anchorfile>group__sigcfunctors.html</anchorfile>
+ <anchor>gada222d975b87d64cfa7a7f29244ae587</anchor>
+ <arglist>(const T_action &_A_action, const T_functor &_A_functor)</arglist>
+ </member>
+ </compound>
+ <compound kind="group">
+ <name>adaptors</name>
+ <title>Adaptors</title>
+ <filename>group__adaptors.html</filename>
+ <subgroup>bind</subgroup>
+ <subgroup>compose</subgroup>
+ <subgroup>exception_catch</subgroup>
+ <subgroup>hide</subgroup>
+ <subgroup>retype</subgroup>
+ <subgroup>track_obj</subgroup>
+ <class kind="struct">sigc::adaptor_base</class>
+ <class kind="struct">sigc::adaptor_functor</class>
+ <class kind="struct">sigc::adaptor_trait</class>
+ <class kind="struct">sigc::adapts</class>
+ <class kind="struct">sigc::deduce_result_type</class>
+ </compound>
+ <compound kind="group">
+ <name>sigcfunctors</name>
+ <title>Functors</title>
+ <filename>group__sigcfunctors.html</filename>
+ <subgroup>slot</subgroup>
+ <subgroup>mem_fun</subgroup>
+ <subgroup>ptr_fun</subgroup>
+ <class kind="class">sigc::can_deduce_result_type_with_decltype</class>
+ <class kind="struct">sigc::functor_base</class>
+ <class kind="struct">sigc::functor_trait</class>
+ <class kind="struct">sigc::visitor</class>
+ <member kind="define">
+ <type>#define</type>
+ <name>SIGC_FUNCTOR_TRAIT</name>
+ <anchorfile>group__sigcfunctors.html</anchorfile>
+ <anchor>ga7a6f5575dc0b0ea896889c782721f6be</anchor>
+ <arglist>(T_functor, T_return)</arglist>
+ </member>
+ <member kind="define">
+ <type>#define</type>
+ <name>SIGC_FUNCTORS_DEDUCE_RESULT_TYPE_WITH_DECLTYPE</name>
+ <anchorfile>group__sigcfunctors.html</anchorfile>
+ <anchor>gadf1ba3cacb09cc5c3c3e399836ec6e50</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="define">
+ <type>#define</type>
+ <name>SIGC_FUNCTORS_HAVE_RESULT_TYPE</name>
+ <anchorfile>group__sigcfunctors.html</anchorfile>
+ <anchor>ga93b6ee8815d90adccfdceed72bcda577</anchor>
+ <arglist></arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>visit_each</name>
+ <anchorfile>group__sigcfunctors.html</anchorfile>
+ <anchor>ga64cb7832acc1e58efb5ffe0b4f5e9404</anchor>
+ <arglist>(const T_action &_A_action, const T_functor &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>void</type>
+ <name>visit_each_type</name>
+ <anchorfile>group__sigcfunctors.html</anchorfile>
+ <anchor>gada222d975b87d64cfa7a7f29244ae587</anchor>
+ <arglist>(const T_action &_A_action, const T_functor &_A_functor)</arglist>
+ </member>
+ </compound>
+ <compound kind="group">
+ <name>signal</name>
+ <title>Signals</title>
+ <filename>group__signal.html</filename>
+ <class kind="struct">sigc::connection</class>
+ <class kind="struct">sigc::nil</class>
+ <class kind="class">sigc::signal</class>
+ <class kind="class">sigc::signal0</class>
+ <class kind="class">sigc::signal1</class>
+ <class kind="class">sigc::signal2</class>
+ <class kind="class">sigc::signal3</class>
+ <class kind="class">sigc::signal4</class>
+ <class kind="class">sigc::signal5</class>
+ <class kind="class">sigc::signal6</class>
+ <class kind="class">sigc::signal7</class>
+ <class kind="class">sigc::signal::accumulated</class>
+ <class kind="class">sigc::signal< T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>::accumulated</class>
+ <class kind="struct">sigc::signal_base</class>
+ <class kind="struct">sigc::slot_const_iterator</class>
+ <class kind="struct">sigc::slot_iterator</class>
+ <class kind="struct">sigc::slot_list</class>
+ <class kind="struct">sigc::trackable</class>
+ </compound>
+ <compound kind="group">
+ <name>slot</name>
+ <title>Slots</title>
+ <filename>group__slot.html</filename>
+ <class kind="struct">sigc::nil</class>
+ <class kind="class">sigc::slot</class>
+ <class kind="class">sigc::slot0</class>
+ <class kind="class">sigc::slot1</class>
+ <class kind="class">sigc::slot2</class>
+ <class kind="class">sigc::slot3</class>
+ <class kind="class">sigc::slot4</class>
+ <class kind="class">sigc::slot5</class>
+ <class kind="class">sigc::slot6</class>
+ <class kind="class">sigc::slot7</class>
+ <class kind="class">sigc::slot< T_return(T_arg...)></class>
+ <class kind="class">sigc::slot_base</class>
+ <docanchor file="group__slot.html" title="Creating Slots">slots-creating</docanchor>
+ <docanchor file="group__slot.html" title="Member Methods and Automatic Disconnection">slots-auto-disconnect</docanchor>
+ <docanchor file="group__slot.html" title="auto">slots-auto</docanchor>
+ <docanchor file="group__slot.html" title="C++ Lambdas">slots-with-lambdas</docanchor>
+ </compound>
+ <compound kind="group">
+ <name>bind</name>
+ <title>bind(), bind_return()</title>
+ <filename>group__bind.html</filename>
+ <class kind="struct">sigc::bind_functor</class>
+ <class kind="struct">sigc::bind_functor< 0, T_functor, T_bound, nil, nil, nil, nil, nil, nil ></class>
+ <class kind="struct">sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil ></class>
+ <class kind="struct">sigc::bind_return_functor</class>
+ <member kind="function">
+ <type>bind_functor< I_location, T_functor, T_bound1 ></type>
+ <name>bind</name>
+ <anchorfile>group__bind.html</anchorfile>
+ <anchor>ga2f099bc6056b32f2a58134ba8537c6f4</anchor>
+ <arglist>(const T_functor &_A_func, T_bound1 _A_b1)</arglist>
+ </member>
+ <member kind="function">
+ <type>bind_functor<-1, T_functor, T_type1 ></type>
+ <name>bind</name>
+ <anchorfile>group__bind.html</anchorfile>
+ <anchor>ga211b3361bb1ae7484b2b276fd926b962</anchor>
+ <arglist>(const T_functor &_A_func, T_type1 _A_b1)</arglist>
+ </member>
+ <member kind="function">
+ <type>bind_functor<-1, T_functor, T_type1, T_type2 ></type>
+ <name>bind</name>
+ <anchorfile>group__bind.html</anchorfile>
+ <anchor>gaf1e076f0734addb8080f1cbcac602591</anchor>
+ <arglist>(const T_functor &_A_func, T_type1 _A_b1, T_type2 _A_b2)</arglist>
+ </member>
+ <member kind="function">
+ <type>bind_functor<-1, T_functor, T_type1, T_type2, T_type3 ></type>
+ <name>bind</name>
+ <anchorfile>group__bind.html</anchorfile>
+ <anchor>ga047061c9fa7d9dcde68c27cceed476a1</anchor>
+ <arglist>(const T_functor &_A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3)</arglist>
+ </member>
+ <member kind="function">
+ <type>bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4 ></type>
+ <name>bind</name>
+ <anchorfile>group__bind.html</anchorfile>
+ <anchor>ga8366abceb86ee653ec2ac50cef9fd16d</anchor>
+ <arglist>(const T_functor &_A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4)</arglist>
+ </member>
+ <member kind="function">
+ <type>bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5 ></type>
+ <name>bind</name>
+ <anchorfile>group__bind.html</anchorfile>
+ <anchor>ga7f163c830d7906906cf21ff0c5e0f17f</anchor>
+ <arglist>(const T_functor &_A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4, T_type5 _A_b5)</arglist>
+ </member>
+ <member kind="function">
+ <type>bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6 ></type>
+ <name>bind</name>
+ <anchorfile>group__bind.html</anchorfile>
+ <anchor>gac370f58b773f68c229c181f07e9b9e79</anchor>
+ <arglist>(const T_functor &_A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4, T_type5 _A_b5, T_type6 _A_b6)</arglist>
+ </member>
+ <member kind="function">
+ <type>bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 ></type>
+ <name>bind</name>
+ <anchorfile>group__bind.html</anchorfile>
+ <anchor>ga962b581ef0c17562bb3317783d3ffe7d</anchor>
+ <arglist>(const T_functor &_A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4, T_type5 _A_b5, T_type6 _A_b6, T_type7 _A_b7)</arglist>
+ </member>
+ <member kind="function">
+ <type>bind_return_functor< T_return, T_functor ></type>
+ <name>bind_return</name>
+ <anchorfile>group__bind.html</anchorfile>
+ <anchor>gaca1ae2466988d67d00a5f2cd16c8d90a</anchor>
+ <arglist>(const T_functor &_A_functor, T_return _A_ret_value)</arglist>
+ </member>
+ </compound>
+ <compound kind="group">
+ <name>compose</name>
+ <title>compose()</title>
+ <filename>group__compose.html</filename>
+ <class kind="struct">sigc::compose1_functor</class>
+ <class kind="struct">sigc::compose2_functor</class>
+ <member kind="function">
+ <type>compose1_functor< T_setter, T_getter ></type>
+ <name>compose</name>
+ <anchorfile>group__compose.html</anchorfile>
+ <anchor>ga34cf5da8f6323bfdc41bc7113d6ad20a</anchor>
+ <arglist>(const T_setter &_A_setter, const T_getter &_A_getter)</arglist>
+ </member>
+ <member kind="function">
+ <type>compose2_functor< T_setter, T_getter1, T_getter2 ></type>
+ <name>compose</name>
+ <anchorfile>group__compose.html</anchorfile>
+ <anchor>ga4abf2a45eb2307a3dc5d870c86b0450d</anchor>
+ <arglist>(const T_setter &_A_setter, const T_getter1 &_A_getter1, const T_getter2 &_A_getter2)</arglist>
+ </member>
+ </compound>
+ <compound kind="group">
+ <name>exception_catch</name>
+ <title>exception_catch()</title>
+ <filename>group__exception__catch.html</filename>
+ </compound>
+ <compound kind="group">
+ <name>hide</name>
+ <title>hide(), hide_return()</title>
+ <filename>group__hide.html</filename>
+ <class kind="struct">sigc::hide_functor</class>
+ <class kind="struct">sigc::hide_functor< 0, T_functor ></class>
+ <class kind="struct">sigc::hide_functor<-1, T_functor ></class>
+ <member kind="function">
+ <type>hide_functor< I_location, T_functor ></type>
+ <name>hide</name>
+ <anchorfile>group__hide.html</anchorfile>
+ <anchor>gaf2cefea3a99acd44f68121424103172d</anchor>
+ <arglist>(const T_functor &_A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>hide_functor<-1, T_functor ></type>
+ <name>hide</name>
+ <anchorfile>group__hide.html</anchorfile>
+ <anchor>gacbbacd3553268d85b95e3a85aefb67e5</anchor>
+ <arglist>(const T_functor &_A_func)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_return_functor< void, T_functor ></type>
+ <name>hide_return</name>
+ <anchorfile>group__hide.html</anchorfile>
+ <anchor>gae4e6f5491471c12440f1c5d480726b98</anchor>
+ <arglist>(const T_functor &_A_functor)</arglist>
+ </member>
+ </compound>
+ <compound kind="group">
+ <name>mem_fun</name>
+ <title>mem_fun()</title>
+ <filename>group__mem__fun.html</filename>
+ <class kind="class">sigc::bound_const_mem_functor0</class>
+ <class kind="class">sigc::bound_const_mem_functor1</class>
+ <class kind="class">sigc::bound_const_mem_functor2</class>
+ <class kind="class">sigc::bound_const_mem_functor3</class>
+ <class kind="class">sigc::bound_const_mem_functor4</class>
+ <class kind="class">sigc::bound_const_mem_functor5</class>
+ <class kind="class">sigc::bound_const_mem_functor6</class>
+ <class kind="class">sigc::bound_const_mem_functor7</class>
+ <class kind="class">sigc::bound_const_volatile_mem_functor0</class>
+ <class kind="class">sigc::bound_const_volatile_mem_functor1</class>
+ <class kind="class">sigc::bound_const_volatile_mem_functor2</class>
+ <class kind="class">sigc::bound_const_volatile_mem_functor3</class>
+ <class kind="class">sigc::bound_const_volatile_mem_functor4</class>
+ <class kind="class">sigc::bound_const_volatile_mem_functor5</class>
+ <class kind="class">sigc::bound_const_volatile_mem_functor6</class>
+ <class kind="class">sigc::bound_const_volatile_mem_functor7</class>
+ <class kind="class">sigc::bound_mem_functor0</class>
+ <class kind="class">sigc::bound_mem_functor1</class>
+ <class kind="class">sigc::bound_mem_functor2</class>
+ <class kind="class">sigc::bound_mem_functor3</class>
+ <class kind="class">sigc::bound_mem_functor4</class>
+ <class kind="class">sigc::bound_mem_functor5</class>
+ <class kind="class">sigc::bound_mem_functor6</class>
+ <class kind="class">sigc::bound_mem_functor7</class>
+ <class kind="class">sigc::bound_volatile_mem_functor0</class>
+ <class kind="class">sigc::bound_volatile_mem_functor1</class>
+ <class kind="class">sigc::bound_volatile_mem_functor2</class>
+ <class kind="class">sigc::bound_volatile_mem_functor3</class>
+ <class kind="class">sigc::bound_volatile_mem_functor4</class>
+ <class kind="class">sigc::bound_volatile_mem_functor5</class>
+ <class kind="class">sigc::bound_volatile_mem_functor6</class>
+ <class kind="class">sigc::bound_volatile_mem_functor7</class>
+ <class kind="class">sigc::const_mem_functor0</class>
+ <class kind="class">sigc::const_mem_functor1</class>
+ <class kind="class">sigc::const_mem_functor2</class>
+ <class kind="class">sigc::const_mem_functor3</class>
+ <class kind="class">sigc::const_mem_functor4</class>
+ <class kind="class">sigc::const_mem_functor5</class>
+ <class kind="class">sigc::const_mem_functor6</class>
+ <class kind="class">sigc::const_mem_functor7</class>
+ <class kind="class">sigc::const_volatile_mem_functor0</class>
+ <class kind="class">sigc::const_volatile_mem_functor1</class>
+ <class kind="class">sigc::const_volatile_mem_functor2</class>
+ <class kind="class">sigc::const_volatile_mem_functor3</class>
+ <class kind="class">sigc::const_volatile_mem_functor4</class>
+ <class kind="class">sigc::const_volatile_mem_functor5</class>
+ <class kind="class">sigc::const_volatile_mem_functor6</class>
+ <class kind="class">sigc::const_volatile_mem_functor7</class>
+ <class kind="class">sigc::mem_functor0</class>
+ <class kind="class">sigc::mem_functor1</class>
+ <class kind="class">sigc::mem_functor2</class>
+ <class kind="class">sigc::mem_functor3</class>
+ <class kind="class">sigc::mem_functor4</class>
+ <class kind="class">sigc::mem_functor5</class>
+ <class kind="class">sigc::mem_functor6</class>
+ <class kind="class">sigc::mem_functor7</class>
+ <class kind="class">sigc::volatile_mem_functor0</class>
+ <class kind="class">sigc::volatile_mem_functor1</class>
+ <class kind="class">sigc::volatile_mem_functor2</class>
+ <class kind="class">sigc::volatile_mem_functor3</class>
+ <class kind="class">sigc::volatile_mem_functor4</class>
+ <class kind="class">sigc::volatile_mem_functor5</class>
+ <class kind="class">sigc::volatile_mem_functor6</class>
+ <class kind="class">sigc::volatile_mem_functor7</class>
+ <member kind="function">
+ <type>bound_mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gaeef6e55681664df29b31edec51ea034d</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)())</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga7de39a04dfc6d37b2d12a25cdccfbe95</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gab1add5c927b51b935b4f2d40558079fa</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga1f1aa3b60c0d2d8b2470bba0b2b36023</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga481ef34d8423d26e8ff0a1916cd295d5</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga09fb13b1684ec7c092ffef695dbb261a</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga0d9b992d69123a524b6c70c458ad0d40</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga5dcdaf235baa50049e6088d246853037</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga7f57ec0156d33b4aa98e259d2e2062db</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)())</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga0df7af9f32990cc624c4bb60782b4f78</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga118b2610268701be95cdc6fddb7bab3b</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gaeb6bd4518e0f0c524dba13a6cbb2e319</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga02c906c95895c58e39ee301bb1577994</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gab138ae1a340be983166b69872826b37d</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga3e3841c4844715d2f2d832ed506f028f</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gaea5a2ace2699b8d1ffe93585e335548d</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gadf6b6d22c503b439019f0a2e77352419</anchor>
+ <arglist>(T_return(T_obj::*_A_func)())</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gab661fef0f04e2e439912eee6989e9657</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1))</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga4bcfe2d4b91ff49bc8bf27af5a5f3bc5</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2))</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gaa3778234963fa65d4f638856d91109d1</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3))</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gadadd40aba6dadd0edbaac609dfae3938</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gaa01df6c622d59cfd2d0d8aa3c04c36d1</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga9030b647c35e06c68342fee34e8fd320</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga54e4bf947e8c93c56931b8e8f7ed0d2e</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun0</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gaf71277763f14050e2d270fcf3ea41dc9</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)())</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun0</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gae03d0b73b85e85d2ad8bc43b19b855e3</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)())</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor0< T_return, T_obj ></type>
+ <name>mem_fun0</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga765b35689a909fbc2a627be8256c5b1f</anchor>
+ <arglist>(T_return(T_obj::*_A_func)())</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun1</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gaade596a4dacfd1429039525bb9f399d0</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun1</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga3dd8d2ed97310dbf4fa394999f0be7b7</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1))</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor1< T_return, T_obj, T_arg1 ></type>
+ <name>mem_fun1</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gae0bebf0d8a2d36d93746c23d9eea668d</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun2</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gaee7652f1a0625df50af50e28b5e2423e</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun2</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga184da4166c8b5409dc4b98d7bc16dff8</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2))</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor2< T_return, T_obj, T_arg1, T_arg2 ></type>
+ <name>mem_fun2</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gab76f41aeada332b353b6fe2e96008831</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun3</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga14e07df139b5cb6897e671c50fc33cde</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun3</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga4f2fdbf02e8cac9492326a4a8ffdd012</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3))</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 ></type>
+ <name>mem_fun3</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga2379e0d689fe4a99c7c669fc29817457</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun4</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga86da5637e2735480d525ffa930e7e21a</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun4</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga94a2525ef116e16598b81b853544a170</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>mem_fun4</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga1bedd04f76ad3e21f614912562e95d83</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun5</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga5c2ca9cef8c857935a59133a73ef61f2</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun5</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gaf060fe3a2be4ff7c0f50aef54b4dc8bf</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>mem_fun5</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga3ef4bb904a751d29e2b6803ef81f72fa</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun6</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga947f4410e62a2996023177e490c882b7</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun6</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>gac0a6242da9bf96642f25c1363dfef383</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>mem_fun6</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga34ace98fbbd18cb635795639d0f22678</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun7</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga1f704e475da2aad1717e059c264c1436</anchor>
+ <arglist>(T_obj &_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</arglist>
+ </member>
+ <member kind="function">
+ <type>bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun7</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga9899534bc8eb78c227d895b396710091</anchor>
+ <arglist>(T_obj *_A_obj, T_return(T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</arglist>
+ </member>
+ <member kind="function">
+ <type>mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>mem_fun7</name>
+ <anchorfile>group__mem__fun.html</anchorfile>
+ <anchor>ga3d174b01bf94dbda3aea58c25c2b3322</anchor>
+ <arglist>(T_return(T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</arglist>
+ </member>
+ </compound>
+ <compound kind="group">
+ <name>ptr_fun</name>
+ <title>ptr_fun()</title>
+ <filename>group__ptr__fun.html</filename>
+ <class kind="class">sigc::pointer_functor0</class>
+ <class kind="class">sigc::pointer_functor1</class>
+ <class kind="class">sigc::pointer_functor2</class>
+ <class kind="class">sigc::pointer_functor3</class>
+ <class kind="class">sigc::pointer_functor4</class>
+ <class kind="class">sigc::pointer_functor5</class>
+ <class kind="class">sigc::pointer_functor6</class>
+ <class kind="class">sigc::pointer_functor7</class>
+ <member kind="function">
+ <type>pointer_functor0< T_return ></type>
+ <name>ptr_fun</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>ga9c80de72f656fb05e81fda622dddc863</anchor>
+ <arglist>(T_return(*_A_func)())</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor1< T_arg1, T_return ></type>
+ <name>ptr_fun</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>ga9b1c3b4ecb24056f5bd38fc6a87f9ad1</anchor>
+ <arglist>(T_return(*_A_func)(T_arg1))</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor2< T_arg1, T_arg2, T_return ></type>
+ <name>ptr_fun</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>ga9c0db14ab1a864b2bad70000325d94c8</anchor>
+ <arglist>(T_return(*_A_func)(T_arg1, T_arg2))</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor3< T_arg1, T_arg2, T_arg3, T_return ></type>
+ <name>ptr_fun</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>ga1cd2254135f3afcfc5ce34e73cf2f48b</anchor>
+ <arglist>(T_return(*_A_func)(T_arg1, T_arg2, T_arg3))</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return ></type>
+ <name>ptr_fun</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>gaa23ae1abf223560bcac001b86d3cc484</anchor>
+ <arglist>(T_return(*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return ></type>
+ <name>ptr_fun</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>gafd3087df10b981325953c93e914d451e</anchor>
+ <arglist>(T_return(*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return ></type>
+ <name>ptr_fun</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>ga0f4d43c3aace56cc5ce0f38886b9ace6</anchor>
+ <arglist>(T_return(*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return ></type>
+ <name>ptr_fun</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>ga65221432dda1b020b73349627762da70</anchor>
+ <arglist>(T_return(*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor0< T_return ></type>
+ <name>ptr_fun0</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>gaad8dffc194a4e4dfa0935ce49d43cd5c</anchor>
+ <arglist>(T_return(*_A_func)())</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor1< T_arg1, T_return ></type>
+ <name>ptr_fun1</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>ga9b1b8e8f5555d6be4ba41be3fb82c94e</anchor>
+ <arglist>(T_return(*_A_func)(T_arg1))</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor2< T_arg1, T_arg2, T_return ></type>
+ <name>ptr_fun2</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>ga0244165b83e41a30b2dfb9523afad446</anchor>
+ <arglist>(T_return(*_A_func)(T_arg1, T_arg2))</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor3< T_arg1, T_arg2, T_arg3, T_return ></type>
+ <name>ptr_fun3</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>ga749e83ea85926d5ad6994d775f98de8d</anchor>
+ <arglist>(T_return(*_A_func)(T_arg1, T_arg2, T_arg3))</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return ></type>
+ <name>ptr_fun4</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>gac6fa01189c786e778d943a2ee60896a4</anchor>
+ <arglist>(T_return(*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4))</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return ></type>
+ <name>ptr_fun5</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>ga37ae059caefef68e441d3dd7d5b11cce</anchor>
+ <arglist>(T_return(*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return ></type>
+ <name>ptr_fun6</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>ga8cdf17b7ec15b260f5147e1171dd5299</anchor>
+ <arglist>(T_return(*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))</arglist>
+ </member>
+ <member kind="function">
+ <type>pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return ></type>
+ <name>ptr_fun7</name>
+ <anchorfile>group__ptr__fun.html</anchorfile>
+ <anchor>ga82e53ab558dae814c16a09edb53617bb</anchor>
+ <arglist>(T_return(*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))</arglist>
+ </member>
+ </compound>
+ <compound kind="group">
+ <name>retype</name>
+ <title>retype(), retype_return()</title>
+ <filename>group__retype.html</filename>
+ <class kind="struct">sigc::retype_functor</class>
+ <class kind="struct">sigc::retype_return_functor</class>
+ <class kind="struct">sigc::retype_return_functor< void, T_functor ></class>
+ <member kind="function">
+ <type>retype_functor< bound_const_mem_functor0< T_return, T_obj > ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga31061f134d93297fd0b4f2d56efafbe3</anchor>
+ <arglist>(const bound_const_mem_functor0< T_return, T_obj > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_mem_functor1< T_return, T_obj, T_arg1 >, T_arg1 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga63ead6c4883a6553446594e6027dc96c</anchor>
+ <arglist>(const bound_const_mem_functor1< T_return, T_obj, T_arg1 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga415bd3f44f1785ce30452a4ca8e46dd0</anchor>
+ <arglist>(const bound_const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga6f86026b9959cdd62287b29407c71e97</anchor>
+ <arglist>(const bound_const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga8fbc58cc94f7f4a46c1557091974a278</anchor>
+ <arglist>(const bound_const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga1d0d963fa703a6f85b8002c3a405c00a</anchor>
+ <arglist>(const bound_const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga39ba6af86d75de1535e4fa8af1e6081b</anchor>
+ <arglist>(const bound_const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga02a44f2ea2386f8e4fa41cb582c2008d</anchor>
+ <arglist>(const bound_const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_volatile_mem_functor0< T_return, T_obj > ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gade9ed42b368ea6eee6d42c8116cd28dd</anchor>
+ <arglist>(const bound_const_volatile_mem_functor0< T_return, T_obj > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 >, T_arg1 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gaab22de279058fd53d5ef720ad3932b56</anchor>
+ <arglist>(const bound_const_volatile_mem_functor1< T_return, T_obj, T_arg1 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga42f7c6ae10273b6577909f89bd76dc1f</anchor>
+ <arglist>(const bound_const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga1b2477c6ed3347fae35c66f25977f9dc</anchor>
+ <arglist>(const bound_const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gad73b9445fab1544d7550db964426520d</anchor>
+ <arglist>(const bound_const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gacbb4a1e1c3447205bf507d6912847015</anchor>
+ <arglist>(const bound_const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gace1ef4f9ca35373adaad3c29db2b918f</anchor>
+ <arglist>(const bound_const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga1ec0f19b59050f8f01c8969835b3c742</anchor>
+ <arglist>(const bound_const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_mem_functor0< T_return, T_obj > ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gaebe9c150af92e230257bbbdb728e5a07</anchor>
+ <arglist>(const bound_mem_functor0< T_return, T_obj > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_mem_functor1< T_return, T_obj, T_arg1 >, T_arg1 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga971017d74a880ee10555ebd32483d188</anchor>
+ <arglist>(const bound_mem_functor1< T_return, T_obj, T_arg1 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gaddf62506fc01f1cdfcadef27e47f9b59</anchor>
+ <arglist>(const bound_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gad916eb17d984df3b7da9b7d3d041168a</anchor>
+ <arglist>(const bound_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga8362fa71a99b71b843205e0482b281fc</anchor>
+ <arglist>(const bound_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga9c139b3254f5020de44a73c7dd795819</anchor>
+ <arglist>(const bound_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga12e152b4340f83bd1f6cec92771fa82a</anchor>
+ <arglist>(const bound_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gadda8029b543d9b657f01e6ba9a9ef8fd</anchor>
+ <arglist>(const bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_volatile_mem_functor0< T_return, T_obj > ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gadc01bb77132048902ec8965d012edcd3</anchor>
+ <arglist>(const bound_volatile_mem_functor0< T_return, T_obj > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_volatile_mem_functor1< T_return, T_obj, T_arg1 >, T_arg1 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga45b921820c277072b6f7e856ddbcfca1</anchor>
+ <arglist>(const bound_volatile_mem_functor1< T_return, T_obj, T_arg1 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gaf420d79b4077b848ef1aef4b68810d6e</anchor>
+ <arglist>(const bound_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga899ae79da0e918ad9fc8f2c8e8066218</anchor>
+ <arglist>(const bound_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga8540037bfd4da57495b60dd9487c6d0b</anchor>
+ <arglist>(const bound_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga31ace8220cbb70b8e7f545ee4c1b6610</anchor>
+ <arglist>(const bound_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga9f45f05c95abc9d20ae9d39589f5d72e</anchor>
+ <arglist>(const bound_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga17e8761db2fafa2d3a92d19d8ce47511</anchor>
+ <arglist>(const bound_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_mem_functor0< T_return, T_obj > ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga0688ca8eb3ee82e191563ba7f81366b2</anchor>
+ <arglist>(const const_mem_functor0< T_return, T_obj > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_mem_functor1< T_return, T_obj, T_arg1 >, T_arg1 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gae035134414ed79a187a6b41a115a3759</anchor>
+ <arglist>(const const_mem_functor1< T_return, T_obj, T_arg1 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga8e9ee582f601451f3aa7c3d37d03b952</anchor>
+ <arglist>(const const_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga81e06b857f7a44b0589125e28535f87f</anchor>
+ <arglist>(const const_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga411bdd3476f80d627c50d47149862ec2</anchor>
+ <arglist>(const const_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga995053759ee8ee89663f9625a4aaf596</anchor>
+ <arglist>(const const_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga851188153c54bb1eb8fee425f9796981</anchor>
+ <arglist>(const const_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gaa951debcabd066f8c3479617aaa9689e</anchor>
+ <arglist>(const const_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_volatile_mem_functor0< T_return, T_obj > ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga312fca59eb8b4ca0e078b1cf7f407212</anchor>
+ <arglist>(const const_volatile_mem_functor0< T_return, T_obj > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_volatile_mem_functor1< T_return, T_obj, T_arg1 >, T_arg1 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga84f4247ab4cc559aed835ccd943fab70</anchor>
+ <arglist>(const const_volatile_mem_functor1< T_return, T_obj, T_arg1 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga271911579dfbac317a53f62f0773e420</anchor>
+ <arglist>(const const_volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga97b4f14b5a7991eba60b635871d6a7f9</anchor>
+ <arglist>(const const_volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga4e9179cc61db0069db209bc7632b3dee</anchor>
+ <arglist>(const const_volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga637af7b3e60f5657dcd62e350ec76675</anchor>
+ <arglist>(const const_volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga17ceafe96cdf3bd37ccd401f413f8748</anchor>
+ <arglist>(const const_volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga75578233ce4f47c5f610569a5ffe84cc</anchor>
+ <arglist>(const const_volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< mem_functor0< T_return, T_obj > ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gabb08dd87f3ec392536b656b6b3e959a0</anchor>
+ <arglist>(const mem_functor0< T_return, T_obj > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< mem_functor1< T_return, T_obj, T_arg1 >, T_arg1 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga5a2600190453d4eb11c14f99973044bc</anchor>
+ <arglist>(const mem_functor1< T_return, T_obj, T_arg1 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< mem_functor2< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga7df338186f09b1c89c2840f6744362e9</anchor>
+ <arglist>(const mem_functor2< T_return, T_obj, T_arg1, T_arg2 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gae2d9d2e91b2f8d256e4ad8da1c3c59e0</anchor>
+ <arglist>(const mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga70e615639e07e90a997a378cf877b106</anchor>
+ <arglist>(const mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gad225dee1d71c68d0ee71f3f0fedcfc1b</anchor>
+ <arglist>(const mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga9c08fe50076854f15c923ab4183aed0f</anchor>
+ <arglist>(const mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga3fbd72b71a4ea4fafa487b5932acd797</anchor>
+ <arglist>(const mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< pointer_functor0< T_return > ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga23978c94d9d3c934803898c3bf48ff7d</anchor>
+ <arglist>(const pointer_functor0< T_return > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< pointer_functor1< T_arg1, T_return >, T_arg1 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga75cc92c15faf06d5293ff34179f21899</anchor>
+ <arglist>(const pointer_functor1< T_arg1, T_return > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< pointer_functor2< T_arg1, T_arg2, T_return >, T_arg1, T_arg2 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga0d67e207b3d753ab71b3801981cfeff3</anchor>
+ <arglist>(const pointer_functor2< T_arg1, T_arg2, T_return > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< pointer_functor3< T_arg1, T_arg2, T_arg3, T_return >, T_arg1, T_arg2, T_arg3 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gaa5dfa926e3bfc7b82e0d14e4d9c9ff32</anchor>
+ <arglist>(const pointer_functor3< T_arg1, T_arg2, T_arg3, T_return > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return >, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>gade02a3d76cf35465acfa39d4e03a40d5</anchor>
+ <arglist>(const pointer_functor4< T_arg1, T_arg2, T_arg3, T_arg4, T_return > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga45fa726d6497c6b0994444fd2569581c</anchor>
+ <arglist>(const pointer_functor5< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga24e30de09c3784220829f52bb068b8c0</anchor>
+ <arglist>(const pointer_functor6< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga09db0b458651a7fcd985e5dd4e50caa0</anchor>
+ <arglist>(const pointer_functor7< T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga8b98eeb2a61b5b1f84dcd1d20fe666f1</anchor>
+ <arglist>(const slot< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< volatile_mem_functor0< T_return, T_obj > ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga53d620659c82cbb84da3812ac874f4b7</anchor>
+ <arglist>(const volatile_mem_functor0< T_return, T_obj > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< volatile_mem_functor1< T_return, T_obj, T_arg1 >, T_arg1 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga6d7f05b930056183bc7537447c80e59b</anchor>
+ <arglist>(const volatile_mem_functor1< T_return, T_obj, T_arg1 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 >, T_arg1, T_arg2 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga5b65e9a9794300c40b1577302e006fbd</anchor>
+ <arglist>(const volatile_mem_functor2< T_return, T_obj, T_arg1, T_arg2 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 >, T_arg1, T_arg2, T_arg3 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga55236721b80a72f40453d1b939316635</anchor>
+ <arglist>(const volatile_mem_functor3< T_return, T_obj, T_arg1, T_arg2, T_arg3 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 >, T_arg1, T_arg2, T_arg3, T_arg4 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga05d2c3c043bed420ba8ba6f40f42f692</anchor>
+ <arglist>(const volatile_mem_functor4< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga42be2d2fbf03fbaba1ad7d8cbbb8bce4</anchor>
+ <arglist>(const volatile_mem_functor5< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga255fac4b456d69d033b327b1d533f054</anchor>
+ <arglist>(const volatile_mem_functor6< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_functor< volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 ></type>
+ <name>retype</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga37a057f88e6ffbb8d4172d6446116796</anchor>
+ <arglist>(const volatile_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > &_A_functor)</arglist>
+ </member>
+ <member kind="function">
+ <type>retype_return_functor< T_return, T_functor ></type>
+ <name>retype_return</name>
+ <anchorfile>group__retype.html</anchorfile>
+ <anchor>ga23a8cdbc12c57fbef0866b5c51d71588</anchor>
+ <arglist>(const T_functor &_A_functor)</arglist>
+ </member>
+ </compound>
+ <compound kind="group">
+ <name>track_obj</name>
+ <title>track_obj()</title>
+ <filename>group__track__obj.html</filename>
+ <class kind="class">sigc::track_obj_functor1</class>
+ <class kind="class">sigc::track_obj_functor2</class>
+ <class kind="class">sigc::track_obj_functor3</class>
+ <class kind="class">sigc::track_obj_functor4</class>
+ <class kind="class">sigc::track_obj_functor5</class>
+ <class kind="class">sigc::track_obj_functor6</class>
+ <class kind="class">sigc::track_obj_functor7</class>
+ <member kind="function">
+ <type>track_obj_functor1< T_functor, T_obj1 ></type>
+ <name>track_obj</name>
+ <anchorfile>group__track__obj.html</anchorfile>
+ <anchor>ga8fd1ab36d123ff83dd4cd8dc58bb28e2</anchor>
+ <arglist>(const T_functor &_A_func, const T_obj1 &_A_obj1)</arglist>
+ </member>
+ <member kind="function">
+ <type>track_obj_functor2< T_functor, T_obj1, T_obj2 ></type>
+ <name>track_obj</name>
+ <anchorfile>group__track__obj.html</anchorfile>
+ <anchor>ga60842510c2387ec49c43149d94fb1b72</anchor>
+ <arglist>(const T_functor &_A_func, const T_obj1 &_A_obj1, const T_obj2 &_A_obj2)</arglist>
+ </member>
+ <member kind="function">
+ <type>track_obj_functor3< T_functor, T_obj1, T_obj2, T_obj3 ></type>
+ <name>track_obj</name>
+ <anchorfile>group__track__obj.html</anchorfile>
+ <anchor>ga52b11304cb05441237a8dcc651cb724e</anchor>
+ <arglist>(const T_functor &_A_func, const T_obj1 &_A_obj1, const T_obj2 &_A_obj2, const T_obj3 &_A_obj3)</arglist>
+ </member>
+ <member kind="function">
+ <type>track_obj_functor4< T_functor, T_obj1, T_obj2, T_obj3, T_obj4 ></type>
+ <name>track_obj</name>
+ <anchorfile>group__track__obj.html</anchorfile>
+ <anchor>gaea44f2388c18ca8508818ff6b7756216</anchor>
+ <arglist>(const T_functor &_A_func, const T_obj1 &_A_obj1, const T_obj2 &_A_obj2, const T_obj3 &_A_obj3, const T_obj4 &_A_obj4)</arglist>
+ </member>
+ <member kind="function">
+ <type>track_obj_functor5< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5 ></type>
+ <name>track_obj</name>
+ <anchorfile>group__track__obj.html</anchorfile>
+ <anchor>ga337dc48ba1e394f572d5d914b83f57a0</anchor>
+ <arglist>(const T_functor &_A_func, const T_obj1 &_A_obj1, const T_obj2 &_A_obj2, const T_obj3 &_A_obj3, const T_obj4 &_A_obj4, const T_obj5 &_A_obj5)</arglist>
+ </member>
+ <member kind="function">
+ <type>track_obj_functor6< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6 ></type>
+ <name>track_obj</name>
+ <anchorfile>group__track__obj.html</anchorfile>
+ <anchor>ga0304ca1269ed352fcc1c81324062302e</anchor>
+ <arglist>(const T_functor &_A_func, const T_obj1 &_A_obj1, const T_obj2 &_A_obj2, const T_obj3 &_A_obj3, const T_obj4 &_A_obj4, const T_obj5 &_A_obj5, const T_obj6 &_A_obj6)</arglist>
+ </member>
+ <member kind="function">
+ <type>track_obj_functor7< T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6, T_obj7 ></type>
+ <name>track_obj</name>
+ <anchorfile>group__track__obj.html</anchorfile>
+ <anchor>ga5ea3e9f52643d7ab1bcfa4f419e7d38f</anchor>
+ <arglist>(const T_functor &_A_func, const T_obj1 &_A_obj1, const T_obj2 &_A_obj2, const T_obj3 &_A_obj3, const T_obj4 &_A_obj4, const T_obj5 &_A_obj5, const T_obj6 &_A_obj6, const T_obj7 &_A_obj7)</arglist>
+ </member>
+ </compound>
+ <compound kind="page">
+ <name>index</name>
+ <title>libsigc++ Reference Manual</title>
+ <filename>index.html</filename>
+ <docanchor file="index.html" title="Description">description</docanchor>
+ <docanchor file="index.html" title="Features">features</docanchor>
+ <docanchor file="index.html" title="Basic Usage">basics</docanchor>
+ <docanchor file="index.html" title="Using Meson">meson</docanchor>
+ <docanchor file="index.html" title="Using Autotools">autotools</docanchor>
+ <docanchor file="index.html" title="Using CMake">cmake</docanchor>
+ <docanchor file="index.html" title="Scope of Documentation">scope</docanchor>
+ </compound>
+</tagfile>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet version="1.0" xmlns="http://www.devhelp.net/book"
+ xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+ <!--
+ Copyright (c) 2009 Daniel Elstner <daniel.kitta@gmail.com>
+
+ XSL transformation from a Doxygen tag file to DevHelp 2 format.
+
+ This script is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation, either version 2 of the License,
+ or (at your option) any later version.
+
+ This script 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 script. If not, see <http://www.gnu.org/licenses/>.
+ -->
+ <xsl:strip-space elements="*"/>
+ <xsl:output method="xml" version="1.0" indent="yes" encoding="UTF-8"/>
+
+ <xsl:param name="book_title"/>
+ <xsl:param name="book_name"/>
+ <xsl:param name="book_base"/>
+
+ <!-- Define keys to filter compounds that are members of other compounds -->
+ <xsl:key name="nested-group" match="compound[@kind='group']" use="subgroup"/>
+ <xsl:key name="nested-scope" match="compound[@kind='namespace']" use="namespace|class"/>
+ <xsl:key name="nested-scope" match="compound[@kind='class' or @kind='struct' or @kind='union']"
+ use="class"/>
+
+ <xsl:template match="/">
+ <book title="{$book_title}" name="{$book_name}" base="{$book_base}"
+ link="index.html" version="2" language="c++">
+ <chapters>
+ <xsl:variable name="modules" select="tagfile/compound[@kind='group']"/>
+ <xsl:if test="$modules">
+ <sub name="Modules" link="modules.html">
+ <!-- Select the top-level group compounds -->
+ <xsl:apply-templates select="$modules[not(key('nested-group', name))]"
+ mode="module-list">
+ <xsl:sort lang="en" select="title"/>
+ </xsl:apply-templates>
+ </sub>
+ </xsl:if>
+ <xsl:variable name="namespaces" select="tagfile/compound[@kind='namespace']"/>
+ <xsl:if test="$namespaces">
+ <sub name="Namespaces" link="namespaces.html">
+ <!-- Generate a flat list of fully qualified namespaces -->
+ <xsl:for-each select="$namespaces">
+ <xsl:sort lang="en" case-order="upper-first" select="name"/>
+ <sub name="{name}" link="{filename}"/>
+ </xsl:for-each>
+ </sub>
+ </xsl:if>
+ <xsl:if test="tagfile/compound[@kind='class' or @kind='struct' or @kind='union']">
+ <sub name="Classes" link="classes.html">
+ <!-- Select the top-level C++ compounds -->
+ <xsl:apply-templates select="tagfile/compound[not(key('nested-scope', name))]"
+ mode="class-list">
+ <xsl:sort lang="en" case-order="upper-first" select="name"/>
+ </xsl:apply-templates>
+ </sub>
+ </xsl:if>
+ </chapters>
+ <functions>
+ <xsl:apply-templates select="tagfile/compound" mode="keyword-list"/>
+ </functions>
+ </book>
+ </xsl:template>
+
+ <xsl:template match="compound" mode="module-list">
+ <xsl:variable name="children" select="subgroup"/>
+ <sub name="{title}" link="{filename}">
+ <!-- Select any subgroup compounds by name -->
+ <xsl:apply-templates select="../compound[@kind='group' and name=$children]"
+ mode="module-list">
+ <xsl:sort lang="en" select="title"/>
+ </xsl:apply-templates>
+ </sub>
+ </xsl:template>
+
+ <xsl:template match="compound[@kind='namespace' or @kind='class' or @kind='struct' or @kind='union']"
+ mode="class-list">
+ <!-- The scope prefix to strip from the name -->
+ <xsl:param name="scope"/>
+ <xsl:variable name="fullname" select="name"/>
+ <xsl:variable name="children" select="namespace|class"/>
+ <sub name="{substring-after($fullname, $scope)}" link="{filename}">
+ <!-- Select any nested C++ compounds by name -->
+ <xsl:apply-templates select="../compound[name=$children]" mode="class-list">
+ <xsl:sort lang="en" case-order="upper-first" select="name"/>
+ <xsl:with-param name="scope" select="concat($fullname, '::')"/>
+ </xsl:apply-templates>
+ </sub>
+ </xsl:template>
+ <!-- Ignore any other kind of compound -->
+ <xsl:template match="*" mode="class-list"/>
+
+ <xsl:template match="compound[@kind='namespace']" mode="keyword-list">
+ <!-- Process members, but do not list the namespace itself as a keyword -->
+ <xsl:apply-templates select="member" mode="keyword-list"/>
+ </xsl:template>
+ <xsl:template match="compound[@kind='class' or @kind='struct' or @kind='union']"
+ mode="keyword-list">
+ <!-- List the compound type itself as a keyword and process its members -->
+ <keyword type="struct" name="{name}" link="{filename}"/>
+ <xsl:apply-templates select="member" mode="keyword-list"/>
+ </xsl:template>
+ <!-- Match leaf compound members -->
+ <xsl:template match="member[@kind='typedef']" mode="keyword-list">
+ <keyword type="typedef" xsl:use-attribute-sets="keyword-member"/>
+ </xsl:template>
+ <xsl:template match="member[@kind='function' or @kind='friend']" mode="keyword-list">
+ <keyword type="function" xsl:use-attribute-sets="keyword-member"/>
+ </xsl:template>
+ <xsl:template match="member[@kind='enumeration']" mode="keyword-list">
+ <keyword type="enum" xsl:use-attribute-sets="keyword-member"/>
+ </xsl:template>
+ <xsl:template match="member[@kind='enumvalue' or @kind='define']" mode="keyword-list">
+ <keyword type="macro" xsl:use-attribute-sets="keyword-member"/>
+ </xsl:template>
+ <!-- Ignore unknown keyword types -->
+ <xsl:template match="*" mode="keyword-list"/>
+
+ <!-- Qualify member name and link anchor -->
+ <xsl:attribute-set name="keyword-member">
+ <xsl:attribute name="name">
+ <xsl:value-of select="concat(../name, '::', name)"/>
+ </xsl:attribute>
+ <xsl:attribute name="link">
+ <xsl:value-of select="concat(anchorfile, '#', anchor)"/>
+ </xsl:attribute>
+ </xsl:attribute-set>
+
+</xsl:stylesheet>
--- /dev/null
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+#ifndef _SIGC_ADAPTORS_ADAPTOR_TRAIT_H_
+#define _SIGC_ADAPTORS_ADAPTOR_TRAIT_H_
+#include <sigc++config.h> //To get SIGC_TEMPLATE_KEYWORD_OPERATOR_OVERLOAD
+#include <sigc++/visit_each.h>
+#include <sigc++/functors/functor_trait.h>
+#include <sigc++/functors/ptr_fun.h>
+#include <sigc++/functors/mem_fun.h>
+#include <sigc++/adaptors/deduce_result_type.h>
+
+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 <class T_functor> 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 <tt>template operator()</tt> member of every argument count
+ * they support. These functions in turn invoke a stored adaptor's
+ * <tt>template operator()</tt>, 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 <class T_functor>
+struct adaptor_functor : public adaptor_base
+{
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef sigc::deduce_result_t<T_functor, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> type; };
+#endif
+ typedef typename functor_trait<T_functor>::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
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ operator()(T_arg1 _A_arg1) const
+ { return functor_(_A_arg1); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ sun_forte_workaround(T_arg1 _A_arg1) const
+ { //Just calling operator() tries to copy the argument:
+ return functor_(_A_arg1);
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2) const
+ { return functor_(_A_arg1, _A_arg2); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2) const
+ { //Just calling operator() tries to copy the argument:
+ return functor_(_A_arg1, _A_arg2);
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3) const
+ { return functor_(_A_arg1, _A_arg2, _A_arg3); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3) const
+ { //Just calling operator() tries to copy the argument:
+ return functor_(_A_arg1, _A_arg2, _A_arg3);
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4) const
+ { return functor_(_A_arg1, _A_arg2, _A_arg3, _A_arg4); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4) const
+ { //Just calling operator() tries to copy the argument:
+ return functor_(_A_arg1, _A_arg2, _A_arg3, _A_arg4);
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @param _A_arg5 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5) const
+ { return functor_(_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5) const
+ { //Just calling operator() tries to copy the argument:
+ return functor_(_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5);
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @param _A_arg5 Argument to be passed on to the functor.
+ * @param _A_arg6 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6) const
+ { return functor_(_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6) const
+ { //Just calling operator() tries to copy the argument:
+ return functor_(_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @param _A_arg5 Argument to be passed on to the functor.
+ * @param _A_arg6 Argument to be passed on to the functor.
+ * @param _A_arg7 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6, T_arg7 _A_arg7) const
+ { return functor_(_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6, _A_arg7); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6, T_arg7 _A_arg7) const
+ { //Just calling operator() tries to copy the argument:
+ return functor_(_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6, _A_arg7);
+ }
+ #endif
+
+ /// 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 <class T_type>
+ explicit adaptor_functor(const T_type& _A_type)
+ : functor_(_A_type)
+ {}
+
+ /// Functor that is invoked from operator()().
+ mutable T_functor functor_;
+};
+
+template <class T_functor>
+typename adaptor_functor<T_functor>::result_type
+adaptor_functor<T_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 <class T_functor>
+struct visitor<adaptor_functor<T_functor> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const adaptor_functor<T_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 <class T_functor, bool I_isadaptor = std::is_base_of<adaptor_base, T_functor>::value> struct adaptor_trait;
+#else
+template <class T_functor, bool I_isadaptor = std::is_base_of<adaptor_base, T_functor>::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 <class T_functor>
+struct adaptor_trait<T_functor, true>
+{
+ 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<functor_type>.
+ */
+template <class T_functor>
+struct adaptor_trait<T_functor, false>
+{
+ typedef typename functor_trait<T_functor>::result_type result_type;
+ typedef typename functor_trait<T_functor>::functor_type functor_type;
+ typedef adaptor_functor<functor_type> 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 <class T_functor>
+ * struct my_adaptor : public sigc::adapts<T_functor>
+ * {
+ * template <class T_arg1=void, class T_arg2=void>
+ * struct deduce_result_type
+ * { typedef sigc::deduce_result_t<T_functor, T_arg1, T_arg2> type; };
+ * typedef typename sigc::functor_trait<T_functor>::result_type result_type;
+ * //
+ * result_type
+ * operator()() const;
+ * //
+ * template <class T_arg1>
+ * typename deduce_result_type<T_arg1>::type
+ * operator()(T_arg1 _A_arg1) const;
+ * //
+ * template <class T_arg1, class T_arg2>
+ * typename deduce_result_type<T_arg1, T_arg2>::type
+ * operator()(T_arg1 _A_arg1, T_arg2 _A_arg2) const;
+ * //
+ * // Constructs a my_adaptor object that wraps the passed functor.
+ * // Initializes adapts<T_functor>::functor_, which is invoked from operator()().
+ * explicit my_adaptor(const T_functor& _A_functor)
+ * : sigc::adapts<T_functor>(_A_functor) {}
+ * };
+ * } // end namespace my_ns
+ * //
+ * // Specialization of sigc::visitor for my_adaptor.
+ * namespace sigc
+ * {
+ * template <class T_functor>
+ * struct visitor<my_ns::my_adaptor<T_functor> >
+ * {
+ * template <class T_action>
+ * static void do_visit_each(const T_action& _A_action,
+ * const my_ns::my_adaptor<T_functor>& _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 <class T_functor>
+struct adapts : public adaptor_base
+{
+ typedef typename adaptor_trait<T_functor>::result_type result_type;
+ typedef typename adaptor_trait<T_functor>::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 */
+#endif /* _SIGC_ADAPTORS_ADAPTOR_TRAIT_H_ */
--- /dev/null
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+#ifndef _SIGC_ADAPTORS_BIND_H_
+#define _SIGC_ADAPTORS_BIND_H_
+#include <sigc++/adaptors/adaptor_trait.h>
+#include <sigc++/adaptors/bound_argument.h>
+
+//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 <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+struct count_void
+ { static const int value=0; };
+template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+struct count_void<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,void>
+ { static const int value=1; };
+template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+struct count_void<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,void,void>
+ { static const int value=2; };
+template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+struct count_void<T_arg1,T_arg2,T_arg3,T_arg4,void,void,void>
+ { static const int value=3; };
+template <class T_arg1,class T_arg2,class T_arg3>
+struct count_void<T_arg1,T_arg2,T_arg3,void,void,void,void>
+ { static const int value=4; };
+template <class T_arg1,class T_arg2>
+struct count_void<T_arg1,T_arg2,void,void,void,void,void>
+ { static const int value=5; };
+template <class T_arg1>
+struct count_void<T_arg1,void,void,void,void,void,void>
+ { static const int value=6; };
+template <>
+struct count_void<void,void,void,void,void,void,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 7 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<void> 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() or std::cref() functions.
+ *
+ * @par Example:
+ * @code
+ * int some_int;
+ * sigc::signal<void> 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<void> 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
+ */
+
+/** 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).
+ * - @e T_type1 Type of the 1st bound argument.
+ * - @e T_type2 Type of the 2nd bound argument.
+ * - @e T_type3 Type of the 3rd bound argument.
+ * - @e T_type4 Type of the 4th bound argument.
+ * - @e T_type5 Type of the 5th bound argument.
+ * - @e T_type6 Type of the 6th bound argument.
+ * - @e T_type7 Type of the 7th bound argument.
+ * - @e T_functor Type of the functor to wrap.
+ *
+ * @ingroup bind
+ */
+template <int I_location, class T_functor, class T_type1=nil, class T_type2=nil, class T_type3=nil, class T_type4=nil, class T_type5=nil, class T_type6=nil, class T_type7=nil>
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+struct bind_functor;
+#else
+struct bind_functor {};
+#endif
+
+/** Adaptor that binds an argument to the wrapped functor.
+ * This template specialization fixes the 1st argument of the wrapped functor.
+ *
+ * @ingroup bind
+ */
+template <class T_functor, class T_bound>
+struct bind_functor<0, T_functor, T_bound, nil, nil, nil, nil, nil, nil> : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>::type type; };
+#endif
+ 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_trait_pass_t<typename unwrap_reference<T_bound>::type>> (bound_.invoke());
+ }
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * bound_ is passed as the 1st argument.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ operator()(T_arg1 _A_arg1)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg1>>
+ (bound_.invoke(), _A_arg1);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ sun_forte_workaround(T_arg1 _A_arg1)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg1>>
+ (bound_.invoke(), _A_arg1);
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * bound_ is passed as the 1st argument.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>>
+ (bound_.invoke(), _A_arg1, _A_arg2);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>>
+ (bound_.invoke(), _A_arg1, _A_arg2);
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * bound_ is passed as the 1st argument.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
+ (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
+ (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3);
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * bound_ is passed as the 1st argument.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
+ (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3, _A_arg4);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
+ (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3, _A_arg4);
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * bound_ is passed as the 1st argument.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @param _A_arg5 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
+ (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
+ (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5);
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * bound_ is passed as the 1st argument.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @param _A_arg5 Argument to be passed on to the functor.
+ * @param _A_arg6 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
+ }
+ #endif
+
+ /** 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(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_bound> _A_bound)
+ : adapts<T_functor>(_A_func), bound_(_A_bound)
+ {}
+
+ /// The argument bound to the functor.
+ bound_argument<T_bound> bound_;
+};
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+/** Adaptor that binds an argument to the wrapped functor.
+ * This template specialization fixes the 2nd argument of the wrapped functor.
+ *
+ * @ingroup bind
+ */
+template <class T_functor, class T_bound>
+struct bind_functor<1, T_functor, T_bound, nil, nil, nil, nil, nil, nil> : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>::type type; };
+ 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_trait_pass_t<typename unwrap_reference<T_bound>::type>> (bound_.invoke());
+ }
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * bound_ is passed as the 2nd argument.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ operator()(T_arg1 _A_arg1)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>>
+ (_A_arg1, bound_.invoke());
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ sun_forte_workaround(T_arg1 _A_arg1)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>>
+ (_A_arg1, bound_.invoke());
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * bound_ is passed as the 2nd argument.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg2>>
+ (_A_arg1, bound_.invoke(), _A_arg2);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg2>>
+ (_A_arg1, bound_.invoke(), _A_arg2);
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * bound_ is passed as the 2nd argument.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
+ (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
+ (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3);
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * bound_ is passed as the 2nd argument.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
+ (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3, _A_arg4);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
+ (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3, _A_arg4);
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * bound_ is passed as the 2nd argument.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @param _A_arg5 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
+ (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3, _A_arg4, _A_arg5);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
+ (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3, _A_arg4, _A_arg5);
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * bound_ is passed as the 2nd argument.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @param _A_arg5 Argument to be passed on to the functor.
+ * @param _A_arg6 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
+ }
+ #endif
+
+ /** 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(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_bound> _A_bound)
+ : adapts<T_functor>(_A_func), bound_(_A_bound)
+ {}
+
+ /// The argument bound to the functor.
+ bound_argument<T_bound> bound_;
+};
+
+/** Adaptor that binds an argument to the wrapped functor.
+ * This template specialization fixes the 3rd argument of the wrapped functor.
+ *
+ * @ingroup bind
+ */
+template <class T_functor, class T_bound>
+struct bind_functor<2, T_functor, T_bound, nil, nil, nil, nil, nil, nil> : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>::type type; };
+ 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_trait_pass_t<typename unwrap_reference<T_bound>::type>> (bound_.invoke());
+ }
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * bound_ is passed as the 3rd argument.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>>
+ (_A_arg1, _A_arg2, bound_.invoke());
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>>
+ (_A_arg1, _A_arg2, bound_.invoke());
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * bound_ is passed as the 3rd argument.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg3>>
+ (_A_arg1, _A_arg2, bound_.invoke(), _A_arg3);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg3>>
+ (_A_arg1, _A_arg2, bound_.invoke(), _A_arg3);
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * bound_ is passed as the 3rd argument.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
+ (_A_arg1, _A_arg2, bound_.invoke(), _A_arg3, _A_arg4);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
+ (_A_arg1, _A_arg2, bound_.invoke(), _A_arg3, _A_arg4);
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * bound_ is passed as the 3rd argument.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @param _A_arg5 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
+ (_A_arg1, _A_arg2, bound_.invoke(), _A_arg3, _A_arg4, _A_arg5);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
+ (_A_arg1, _A_arg2, bound_.invoke(), _A_arg3, _A_arg4, _A_arg5);
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * bound_ is passed as the 3rd argument.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @param _A_arg5 Argument to be passed on to the functor.
+ * @param _A_arg6 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_arg1, _A_arg2, bound_.invoke(), _A_arg3, _A_arg4, _A_arg5, _A_arg6);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_arg1, _A_arg2, bound_.invoke(), _A_arg3, _A_arg4, _A_arg5, _A_arg6);
+ }
+ #endif
+
+ /** 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(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_bound> _A_bound)
+ : adapts<T_functor>(_A_func), bound_(_A_bound)
+ {}
+
+ /// The argument bound to the functor.
+ bound_argument<T_bound> bound_;
+};
+
+/** Adaptor that binds an argument to the wrapped functor.
+ * This template specialization fixes the 4th argument of the wrapped functor.
+ *
+ * @ingroup bind
+ */
+template <class T_functor, class T_bound>
+struct bind_functor<3, T_functor, T_bound, nil, nil, nil, nil, nil, nil> : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>::type type; };
+ 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_trait_pass_t<typename unwrap_reference<T_bound>::type>> (bound_.invoke());
+ }
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * bound_ is passed as the 4th argument.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>>
+ (_A_arg1, _A_arg2, _A_arg3, bound_.invoke());
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>>
+ (_A_arg1, _A_arg2, _A_arg3, bound_.invoke());
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * bound_ is passed as the 4th argument.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg4>>
+ (_A_arg1, _A_arg2, _A_arg3, bound_.invoke(), _A_arg4);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg4>>
+ (_A_arg1, _A_arg2, _A_arg3, bound_.invoke(), _A_arg4);
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * bound_ is passed as the 4th argument.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @param _A_arg5 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
+ (_A_arg1, _A_arg2, _A_arg3, bound_.invoke(), _A_arg4, _A_arg5);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
+ (_A_arg1, _A_arg2, _A_arg3, bound_.invoke(), _A_arg4, _A_arg5);
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * bound_ is passed as the 4th argument.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @param _A_arg5 Argument to be passed on to the functor.
+ * @param _A_arg6 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_arg1, _A_arg2, _A_arg3, bound_.invoke(), _A_arg4, _A_arg5, _A_arg6);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_arg1, _A_arg2, _A_arg3, bound_.invoke(), _A_arg4, _A_arg5, _A_arg6);
+ }
+ #endif
+
+ /** 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(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_bound> _A_bound)
+ : adapts<T_functor>(_A_func), bound_(_A_bound)
+ {}
+
+ /// The argument bound to the functor.
+ bound_argument<T_bound> bound_;
+};
+
+/** Adaptor that binds an argument to the wrapped functor.
+ * This template specialization fixes the 5th argument of the wrapped functor.
+ *
+ * @ingroup bind
+ */
+template <class T_functor, class T_bound>
+struct bind_functor<4, T_functor, T_bound, nil, nil, nil, nil, nil, nil> : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>::type type; };
+ 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_trait_pass_t<typename unwrap_reference<T_bound>::type>> (bound_.invoke());
+ }
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * bound_ is passed as the 5th argument.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, bound_.invoke());
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, bound_.invoke());
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * bound_ is passed as the 5th argument.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @param _A_arg5 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg5>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, bound_.invoke(), _A_arg5);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg5>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, bound_.invoke(), _A_arg5);
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * bound_ is passed as the 5th argument.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @param _A_arg5 Argument to be passed on to the functor.
+ * @param _A_arg6 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, bound_.invoke(), _A_arg5, _A_arg6);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, bound_.invoke(), _A_arg5, _A_arg6);
+ }
+ #endif
+
+ /** 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(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_bound> _A_bound)
+ : adapts<T_functor>(_A_func), bound_(_A_bound)
+ {}
+
+ /// The argument bound to the functor.
+ bound_argument<T_bound> bound_;
+};
+
+/** Adaptor that binds an argument to the wrapped functor.
+ * This template specialization fixes the 6th argument of the wrapped functor.
+ *
+ * @ingroup bind
+ */
+template <class T_functor, class T_bound>
+struct bind_functor<5, T_functor, T_bound, nil, nil, nil, nil, nil, nil> : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg6>>::type type; };
+ 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_trait_pass_t<typename unwrap_reference<T_bound>::type>> (bound_.invoke());
+ }
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * bound_ is passed as the 6th argument.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @param _A_arg5 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, bound_.invoke());
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, bound_.invoke());
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * bound_ is passed as the 6th argument.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @param _A_arg5 Argument to be passed on to the functor.
+ * @param _A_arg6 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg6>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, bound_.invoke(), _A_arg6);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg6>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, bound_.invoke(), _A_arg6);
+ }
+ #endif
+
+ /** 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(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_bound> _A_bound)
+ : adapts<T_functor>(_A_func), bound_(_A_bound)
+ {}
+
+ /// The argument bound to the functor.
+ bound_argument<T_bound> bound_;
+};
+
+/** Adaptor that binds an argument to the wrapped functor.
+ * This template specialization fixes the 7th argument of the wrapped functor.
+ *
+ * @ingroup bind
+ */
+template <class T_functor, class T_bound>
+struct bind_functor<6, T_functor, T_bound, nil, nil, nil, nil, nil, nil> : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>>::type type; };
+ 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_trait_pass_t<typename unwrap_reference<T_bound>::type>> (bound_.invoke());
+ }
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * bound_ is passed as the 7th argument.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @param _A_arg5 Argument to be passed on to the functor.
+ * @param _A_arg6 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6, bound_.invoke());
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6, bound_.invoke());
+ }
+ #endif
+
+ /** 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(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_bound> _A_bound)
+ : adapts<T_functor>(_A_func), bound_(_A_bound)
+ {}
+
+ /// The argument bound to the functor.
+ bound_argument<T_bound> bound_;
+};
+#endif // DOXYGEN_SHOULD_SKIP_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 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 <int T_loc, class T_functor, class T_bound>
+struct visitor<bind_functor<T_loc, T_functor, T_bound> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bind_functor<T_loc, T_functor, T_bound>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.functor_);
+ sigc::visit_each(_A_action, _A_target.bound_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** 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 <class T_functor, class T_type1>
+struct bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil> : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+ template <int count, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ struct deduce_result_type_internal
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>::type type; };
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ struct deduce_result_type_internal<2, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>::type type; };
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ struct deduce_result_type_internal<3, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>::type type; };
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ struct deduce_result_type_internal<4, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>::type type; };
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ struct deduce_result_type_internal<5, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>::type type; };
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ struct deduce_result_type_internal<6, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>::type type; };
+
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type {
+ typedef typename deduce_result_type_internal<internal::count_void<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::value,
+ T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type type;
+ };
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+ 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_trait_pass_t<typename unwrap_reference<T_type1>::type>> (bound1_.invoke());
+ }
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * The last 1 argument(s) are fixed.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ operator()(T_arg1 _A_arg1)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>
+ (_A_arg1, bound1_.invoke());
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ sun_forte_workaround(T_arg1 _A_arg1)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>
+ (_A_arg1, bound1_.invoke());
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * The last 1 argument(s) are fixed.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>
+ (_A_arg1, _A_arg2, bound1_.invoke());
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>
+ (_A_arg1, _A_arg2, bound1_.invoke());
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * The last 1 argument(s) are fixed.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>
+ (_A_arg1, _A_arg2, _A_arg3, bound1_.invoke());
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>
+ (_A_arg1, _A_arg2, _A_arg3, bound1_.invoke());
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * The last 1 argument(s) are fixed.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, bound1_.invoke());
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, bound1_.invoke());
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * The last 1 argument(s) are fixed.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @param _A_arg5 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, bound1_.invoke());
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, bound1_.invoke());
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * The last 1 argument(s) are fixed.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @param _A_arg5 Argument to be passed on to the functor.
+ * @param _A_arg6 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6, bound1_.invoke());
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6, bound1_.invoke());
+ }
+ #endif
+
+ /** Constructs a bind_functor object that binds an argument to the passed functor.
+ * @param _A_func Functor to invoke from operator()().
+ * @param _A_bound1 Argument to bind to the functor.
+ */
+ bind_functor(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_type1> _A_bound1)
+ : adapts<T_functor>(_A_func), bound1_(_A_bound1)
+ {}
+
+ /// The argument bound to the functor.
+ bound_argument<T_type1> bound1_;
+};
+
+#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 <class T_functor, class T_type1>
+struct visitor<bind_functor<-1, T_functor, T_type1> >
+{
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bind_functor<-1, T_functor, T_type1>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.functor_);
+ sigc::visit_each(_A_action, _A_target.bound1_);
+ }
+};
+
+/** Adaptor that binds 2 argument(s) to the wrapped functor.
+ * This template specialization fixes the last 2 argument(s) of the wrapped functor.
+ *
+ * @ingroup bind
+ */
+template <class T_functor, class T_type1, class T_type2>
+struct bind_functor<-1, T_functor, T_type1, T_type2, nil, nil, nil, nil, nil> : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+ template <int count, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ struct deduce_result_type_internal
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>::type type; };
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ struct deduce_result_type_internal<3, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>::type type; };
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ struct deduce_result_type_internal<4, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>::type type; };
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ struct deduce_result_type_internal<5, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>::type type; };
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ struct deduce_result_type_internal<6, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>::type type; };
+
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type {
+ typedef typename deduce_result_type_internal<internal::count_void<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::value,
+ T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type type;
+ };
+ 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_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>> (bound1_.invoke(), bound2_.invoke());
+ }
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * The last 2 argument(s) are fixed.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ operator()(T_arg1 _A_arg1)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>
+ (_A_arg1, bound1_.invoke(), bound2_.invoke());
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ sun_forte_workaround(T_arg1 _A_arg1)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>
+ (_A_arg1, bound1_.invoke(), bound2_.invoke());
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * The last 2 argument(s) are fixed.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>
+ (_A_arg1, _A_arg2, bound1_.invoke(), bound2_.invoke());
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>
+ (_A_arg1, _A_arg2, bound1_.invoke(), bound2_.invoke());
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * The last 2 argument(s) are fixed.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>
+ (_A_arg1, _A_arg2, _A_arg3, bound1_.invoke(), bound2_.invoke());
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>
+ (_A_arg1, _A_arg2, _A_arg3, bound1_.invoke(), bound2_.invoke());
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * The last 2 argument(s) are fixed.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, bound1_.invoke(), bound2_.invoke());
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, bound1_.invoke(), bound2_.invoke());
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * The last 2 argument(s) are fixed.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @param _A_arg5 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, bound1_.invoke(), bound2_.invoke());
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, bound1_.invoke(), bound2_.invoke());
+ }
+ #endif
+
+ /** Constructs a bind_functor object that binds an argument to the passed functor.
+ * @param _A_func Functor to invoke from operator()().
+ * @param _A_bound1 Argument to bind to the functor.
+ * @param _A_bound2 Argument to bind to the functor.
+ */
+ bind_functor(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_type1> _A_bound1, type_trait_take_t<T_type2> _A_bound2)
+ : adapts<T_functor>(_A_func), bound1_(_A_bound1), bound2_(_A_bound2)
+ {}
+
+ /// The argument bound to the functor.
+ bound_argument<T_type1> bound1_;
+ bound_argument<T_type2> bound2_;
+};
+
+//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 <class T_functor, class T_type1, class T_type2>
+struct visitor<bind_functor<-1, T_functor, T_type1, T_type2> >
+{
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bind_functor<-1, T_functor, T_type1, T_type2>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.functor_);
+ sigc::visit_each(_A_action, _A_target.bound1_);
+ sigc::visit_each(_A_action, _A_target.bound2_);
+ }
+};
+
+/** Adaptor that binds 3 argument(s) to the wrapped functor.
+ * This template specialization fixes the last 3 argument(s) of the wrapped functor.
+ *
+ * @ingroup bind
+ */
+template <class T_functor, class T_type1, class T_type2, class T_type3>
+struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, nil, nil, nil, nil> : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+ template <int count, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ struct deduce_result_type_internal
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>>::type type; };
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ struct deduce_result_type_internal<4, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>>::type type; };
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ struct deduce_result_type_internal<5, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>>::type type; };
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ struct deduce_result_type_internal<6, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>>::type type; };
+
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type {
+ typedef typename deduce_result_type_internal<internal::count_void<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::value,
+ T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type type;
+ };
+ 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_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>> (bound1_.invoke(), bound2_.invoke(), bound3_.invoke());
+ }
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * The last 3 argument(s) are fixed.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ operator()(T_arg1 _A_arg1)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>>
+ (_A_arg1, bound1_.invoke(), bound2_.invoke(), bound3_.invoke());
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ sun_forte_workaround(T_arg1 _A_arg1)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>>
+ (_A_arg1, bound1_.invoke(), bound2_.invoke(), bound3_.invoke());
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * The last 3 argument(s) are fixed.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>>
+ (_A_arg1, _A_arg2, bound1_.invoke(), bound2_.invoke(), bound3_.invoke());
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>>
+ (_A_arg1, _A_arg2, bound1_.invoke(), bound2_.invoke(), bound3_.invoke());
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * The last 3 argument(s) are fixed.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>>
+ (_A_arg1, _A_arg2, _A_arg3, bound1_.invoke(), bound2_.invoke(), bound3_.invoke());
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>>
+ (_A_arg1, _A_arg2, _A_arg3, bound1_.invoke(), bound2_.invoke(), bound3_.invoke());
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * The last 3 argument(s) are fixed.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, bound1_.invoke(), bound2_.invoke(), bound3_.invoke());
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, bound1_.invoke(), bound2_.invoke(), bound3_.invoke());
+ }
+ #endif
+
+ /** Constructs a bind_functor object that binds an argument to the passed functor.
+ * @param _A_func Functor to invoke from operator()().
+ * @param _A_bound1 Argument to bind to the functor.
+ * @param _A_bound2 Argument to bind to the functor.
+ * @param _A_bound3 Argument to bind to the functor.
+ */
+ bind_functor(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_type1> _A_bound1, type_trait_take_t<T_type2> _A_bound2, type_trait_take_t<T_type3> _A_bound3)
+ : adapts<T_functor>(_A_func), bound1_(_A_bound1), bound2_(_A_bound2), bound3_(_A_bound3)
+ {}
+
+ /// The argument bound to the functor.
+ bound_argument<T_type1> bound1_;
+ bound_argument<T_type2> bound2_;
+ bound_argument<T_type3> bound3_;
+};
+
+//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 <class T_functor, class T_type1, class T_type2, class T_type3>
+struct visitor<bind_functor<-1, T_functor, T_type1, T_type2, T_type3> >
+{
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bind_functor<-1, T_functor, T_type1, T_type2, T_type3>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.functor_);
+ sigc::visit_each(_A_action, _A_target.bound1_);
+ sigc::visit_each(_A_action, _A_target.bound2_);
+ sigc::visit_each(_A_action, _A_target.bound3_);
+ }
+};
+
+/** Adaptor that binds 4 argument(s) to the wrapped functor.
+ * This template specialization fixes the last 4 argument(s) of the wrapped functor.
+ *
+ * @ingroup bind
+ */
+template <class T_functor, class T_type1, class T_type2, class T_type3, class T_type4>
+struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, nil, nil, nil> : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+ template <int count, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ struct deduce_result_type_internal
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>>::type type; };
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ struct deduce_result_type_internal<5, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>>::type type; };
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ struct deduce_result_type_internal<6, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>>::type type; };
+
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type {
+ typedef typename deduce_result_type_internal<internal::count_void<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::value,
+ T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type type;
+ };
+ 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_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>> (bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke());
+ }
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * The last 4 argument(s) are fixed.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ operator()(T_arg1 _A_arg1)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>>
+ (_A_arg1, bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke());
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ sun_forte_workaround(T_arg1 _A_arg1)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>>
+ (_A_arg1, bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke());
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * The last 4 argument(s) are fixed.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>>
+ (_A_arg1, _A_arg2, bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke());
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>>
+ (_A_arg1, _A_arg2, bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke());
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * The last 4 argument(s) are fixed.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>>
+ (_A_arg1, _A_arg2, _A_arg3, bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke());
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>>
+ (_A_arg1, _A_arg2, _A_arg3, bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke());
+ }
+ #endif
+
+ /** Constructs a bind_functor object that binds an argument to the passed functor.
+ * @param _A_func Functor to invoke from operator()().
+ * @param _A_bound1 Argument to bind to the functor.
+ * @param _A_bound2 Argument to bind to the functor.
+ * @param _A_bound3 Argument to bind to the functor.
+ * @param _A_bound4 Argument to bind to the functor.
+ */
+ bind_functor(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_type1> _A_bound1, type_trait_take_t<T_type2> _A_bound2, type_trait_take_t<T_type3> _A_bound3, type_trait_take_t<T_type4> _A_bound4)
+ : adapts<T_functor>(_A_func), bound1_(_A_bound1), bound2_(_A_bound2), bound3_(_A_bound3), bound4_(_A_bound4)
+ {}
+
+ /// The argument bound to the functor.
+ bound_argument<T_type1> bound1_;
+ bound_argument<T_type2> bound2_;
+ bound_argument<T_type3> bound3_;
+ bound_argument<T_type4> bound4_;
+};
+
+//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 <class T_functor, class T_type1, class T_type2, class T_type3, class T_type4>
+struct visitor<bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4> >
+{
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.functor_);
+ sigc::visit_each(_A_action, _A_target.bound1_);
+ sigc::visit_each(_A_action, _A_target.bound2_);
+ sigc::visit_each(_A_action, _A_target.bound3_);
+ sigc::visit_each(_A_action, _A_target.bound4_);
+ }
+};
+
+/** Adaptor that binds 5 argument(s) to the wrapped functor.
+ * This template specialization fixes the last 5 argument(s) of the wrapped functor.
+ *
+ * @ingroup bind
+ */
+template <class T_functor, class T_type1, class T_type2, class T_type3, class T_type4, class T_type5>
+struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, nil, nil> : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+ template <int count, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ struct deduce_result_type_internal
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>, type_trait_pass_t<typename unwrap_reference<T_type5>::type>>::type type; };
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ struct deduce_result_type_internal<6, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>, type_trait_pass_t<typename unwrap_reference<T_type5>::type>>::type type; };
+
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type {
+ typedef typename deduce_result_type_internal<internal::count_void<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::value,
+ T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type type;
+ };
+ 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_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>, type_trait_pass_t<typename unwrap_reference<T_type5>::type>> (bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke(), bound5_.invoke());
+ }
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * The last 5 argument(s) are fixed.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ operator()(T_arg1 _A_arg1)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>, type_trait_pass_t<typename unwrap_reference<T_type5>::type>>
+ (_A_arg1, bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke(), bound5_.invoke());
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ sun_forte_workaround(T_arg1 _A_arg1)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>, type_trait_pass_t<typename unwrap_reference<T_type5>::type>>
+ (_A_arg1, bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke(), bound5_.invoke());
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * The last 5 argument(s) are fixed.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>, type_trait_pass_t<typename unwrap_reference<T_type5>::type>>
+ (_A_arg1, _A_arg2, bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke(), bound5_.invoke());
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>, type_trait_pass_t<typename unwrap_reference<T_type5>::type>>
+ (_A_arg1, _A_arg2, bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke(), bound5_.invoke());
+ }
+ #endif
+
+ /** Constructs a bind_functor object that binds an argument to the passed functor.
+ * @param _A_func Functor to invoke from operator()().
+ * @param _A_bound1 Argument to bind to the functor.
+ * @param _A_bound2 Argument to bind to the functor.
+ * @param _A_bound3 Argument to bind to the functor.
+ * @param _A_bound4 Argument to bind to the functor.
+ * @param _A_bound5 Argument to bind to the functor.
+ */
+ bind_functor(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_type1> _A_bound1, type_trait_take_t<T_type2> _A_bound2, type_trait_take_t<T_type3> _A_bound3, type_trait_take_t<T_type4> _A_bound4, type_trait_take_t<T_type5> _A_bound5)
+ : adapts<T_functor>(_A_func), bound1_(_A_bound1), bound2_(_A_bound2), bound3_(_A_bound3), bound4_(_A_bound4), bound5_(_A_bound5)
+ {}
+
+ /// The argument bound to the functor.
+ bound_argument<T_type1> bound1_;
+ bound_argument<T_type2> bound2_;
+ bound_argument<T_type3> bound3_;
+ bound_argument<T_type4> bound4_;
+ bound_argument<T_type5> bound5_;
+};
+
+//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 <class T_functor, class T_type1, class T_type2, class T_type3, class T_type4, class T_type5>
+struct visitor<bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5> >
+{
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.functor_);
+ sigc::visit_each(_A_action, _A_target.bound1_);
+ sigc::visit_each(_A_action, _A_target.bound2_);
+ sigc::visit_each(_A_action, _A_target.bound3_);
+ sigc::visit_each(_A_action, _A_target.bound4_);
+ sigc::visit_each(_A_action, _A_target.bound5_);
+ }
+};
+
+/** Adaptor that binds 6 argument(s) to the wrapped functor.
+ * This template specialization fixes the last 6 argument(s) of the wrapped functor.
+ *
+ * @ingroup bind
+ */
+template <class T_functor, class T_type1, class T_type2, class T_type3, class T_type4, class T_type5, class T_type6>
+struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, nil> : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+ template <int count, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ struct deduce_result_type_internal
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>, type_trait_pass_t<typename unwrap_reference<T_type5>::type>, type_trait_pass_t<typename unwrap_reference<T_type6>::type>>::type type; };
+
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type {
+ typedef typename deduce_result_type_internal<internal::count_void<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::value,
+ T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type type;
+ };
+ 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_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>, type_trait_pass_t<typename unwrap_reference<T_type5>::type>, type_trait_pass_t<typename unwrap_reference<T_type6>::type>> (bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke(), bound5_.invoke(), bound6_.invoke());
+ }
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * The last 6 argument(s) are fixed.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ operator()(T_arg1 _A_arg1)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>, type_trait_pass_t<typename unwrap_reference<T_type5>::type>, type_trait_pass_t<typename unwrap_reference<T_type6>::type>>
+ (_A_arg1, bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke(), bound5_.invoke(), bound6_.invoke());
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ sun_forte_workaround(T_arg1 _A_arg1)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>, type_trait_pass_t<typename unwrap_reference<T_type5>::type>, type_trait_pass_t<typename unwrap_reference<T_type6>::type>>
+ (_A_arg1, bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke(), bound5_.invoke(), bound6_.invoke());
+ }
+ #endif
+
+ /** Constructs a bind_functor object that binds an argument to the passed functor.
+ * @param _A_func Functor to invoke from operator()().
+ * @param _A_bound1 Argument to bind to the functor.
+ * @param _A_bound2 Argument to bind to the functor.
+ * @param _A_bound3 Argument to bind to the functor.
+ * @param _A_bound4 Argument to bind to the functor.
+ * @param _A_bound5 Argument to bind to the functor.
+ * @param _A_bound6 Argument to bind to the functor.
+ */
+ bind_functor(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_type1> _A_bound1, type_trait_take_t<T_type2> _A_bound2, type_trait_take_t<T_type3> _A_bound3, type_trait_take_t<T_type4> _A_bound4, type_trait_take_t<T_type5> _A_bound5, type_trait_take_t<T_type6> _A_bound6)
+ : adapts<T_functor>(_A_func), bound1_(_A_bound1), bound2_(_A_bound2), bound3_(_A_bound3), bound4_(_A_bound4), bound5_(_A_bound5), bound6_(_A_bound6)
+ {}
+
+ /// The argument bound to the functor.
+ bound_argument<T_type1> bound1_;
+ bound_argument<T_type2> bound2_;
+ bound_argument<T_type3> bound3_;
+ bound_argument<T_type4> bound4_;
+ bound_argument<T_type5> bound5_;
+ bound_argument<T_type6> bound6_;
+};
+
+//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 <class T_functor, class T_type1, class T_type2, class T_type3, class T_type4, class T_type5, class T_type6>
+struct visitor<bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6> >
+{
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.functor_);
+ sigc::visit_each(_A_action, _A_target.bound1_);
+ sigc::visit_each(_A_action, _A_target.bound2_);
+ sigc::visit_each(_A_action, _A_target.bound3_);
+ sigc::visit_each(_A_action, _A_target.bound4_);
+ sigc::visit_each(_A_action, _A_target.bound5_);
+ sigc::visit_each(_A_action, _A_target.bound6_);
+ }
+};
+
+/** Adaptor that binds 7 argument(s) to the wrapped functor.
+ * This template specialization fixes the last 7 argument(s) of the wrapped functor.
+ *
+ * @ingroup bind
+ */
+template <class T_functor, class T_type1, class T_type2, class T_type3, class T_type4, class T_type5, class T_type6, class T_type7>
+struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7> : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+ template <int count, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ struct deduce_result_type_internal
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>, type_trait_pass_t<typename unwrap_reference<T_type5>::type>, type_trait_pass_t<typename unwrap_reference<T_type6>::type>, type_trait_pass_t<typename unwrap_reference<T_type7>::type>>::type type; };
+
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type {
+ typedef typename deduce_result_type_internal<internal::count_void<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::value,
+ T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type type;
+ };
+ 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_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>, type_trait_pass_t<typename unwrap_reference<T_type5>::type>, type_trait_pass_t<typename unwrap_reference<T_type6>::type>, type_trait_pass_t<typename unwrap_reference<T_type7>::type>> (bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke(), bound5_.invoke(), bound6_.invoke(), bound7_.invoke());
+ }
+
+ /** Constructs a bind_functor object that binds an argument to the passed functor.
+ * @param _A_func Functor to invoke from operator()().
+ * @param _A_bound1 Argument to bind to the functor.
+ * @param _A_bound2 Argument to bind to the functor.
+ * @param _A_bound3 Argument to bind to the functor.
+ * @param _A_bound4 Argument to bind to the functor.
+ * @param _A_bound5 Argument to bind to the functor.
+ * @param _A_bound6 Argument to bind to the functor.
+ * @param _A_bound7 Argument to bind to the functor.
+ */
+ bind_functor(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_type1> _A_bound1, type_trait_take_t<T_type2> _A_bound2, type_trait_take_t<T_type3> _A_bound3, type_trait_take_t<T_type4> _A_bound4, type_trait_take_t<T_type5> _A_bound5, type_trait_take_t<T_type6> _A_bound6, type_trait_take_t<T_type7> _A_bound7)
+ : adapts<T_functor>(_A_func), bound1_(_A_bound1), bound2_(_A_bound2), bound3_(_A_bound3), bound4_(_A_bound4), bound5_(_A_bound5), bound6_(_A_bound6), bound7_(_A_bound7)
+ {}
+
+ /// The argument bound to the functor.
+ bound_argument<T_type1> bound1_;
+ bound_argument<T_type2> bound2_;
+ bound_argument<T_type3> bound3_;
+ bound_argument<T_type4> bound4_;
+ bound_argument<T_type5> bound5_;
+ bound_argument<T_type6> bound6_;
+ bound_argument<T_type7> bound7_;
+};
+
+//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 <class T_functor, class T_type1, class T_type2, class T_type3, class T_type4, class T_type5, class T_type6, class T_type7>
+struct visitor<bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7> >
+{
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.functor_);
+ sigc::visit_each(_A_action, _A_target.bound1_);
+ sigc::visit_each(_A_action, _A_target.bound2_);
+ sigc::visit_each(_A_action, _A_target.bound3_);
+ sigc::visit_each(_A_action, _A_target.bound4_);
+ sigc::visit_each(_A_action, _A_target.bound5_);
+ sigc::visit_each(_A_action, _A_target.bound6_);
+ sigc::visit_each(_A_action, _A_target.bound7_);
+ }
+};
+#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 _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 <int I_location, class T_bound1, class T_functor>
+inline bind_functor<I_location, T_functor, T_bound1>
+bind(const T_functor& _A_func, T_bound1 _A_b1)
+{
+ return bind_functor<I_location, T_functor, T_bound1>
+ (_A_func, _A_b1);
+}
+
+/** 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.
+ * @param _A_b1 Argument to bind to @e _A_func.
+ * @return Adaptor that executes _A_func with the bound argument on invokation.
+ *
+ * @ingroup bind
+ */
+template <class T_type1, class T_functor>
+inline bind_functor<-1, T_functor,
+ T_type1>
+bind(const T_functor& _A_func, T_type1 _A_b1)
+{ return bind_functor<-1, T_functor,
+ T_type1>
+ (_A_func, _A_b1);
+}
+
+/** Creates an adaptor of type sigc::bind_functor which fixes the last 2 argument(s) of the passed functor.
+ * This function overload fixes the last 2 argument(s) of @e _A_func.
+ *
+ * @param _A_func Functor that should be wrapped.
+ * @param _A_b1 Argument to bind to @e _A_func.
+ * @param _A_b2 Argument to bind to @e _A_func.
+ * @return Adaptor that executes _A_func with the bound argument on invokation.
+ *
+ * @ingroup bind
+ */
+template <class T_type1, class T_type2, class T_functor>
+inline bind_functor<-1, T_functor,
+ T_type1,
+ T_type2>
+bind(const T_functor& _A_func, T_type1 _A_b1, T_type2 _A_b2)
+{ return bind_functor<-1, T_functor,
+ T_type1,
+ T_type2>
+ (_A_func, _A_b1, _A_b2);
+}
+
+/** Creates an adaptor of type sigc::bind_functor which fixes the last 3 argument(s) of the passed functor.
+ * This function overload fixes the last 3 argument(s) of @e _A_func.
+ *
+ * @param _A_func Functor that should be wrapped.
+ * @param _A_b1 Argument to bind to @e _A_func.
+ * @param _A_b2 Argument to bind to @e _A_func.
+ * @param _A_b3 Argument to bind to @e _A_func.
+ * @return Adaptor that executes _A_func with the bound argument on invokation.
+ *
+ * @ingroup bind
+ */
+template <class T_type1, class T_type2, class T_type3, class T_functor>
+inline bind_functor<-1, T_functor,
+ T_type1,
+ T_type2,
+ T_type3>
+bind(const T_functor& _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3)
+{ return bind_functor<-1, T_functor,
+ T_type1,
+ T_type2,
+ T_type3>
+ (_A_func, _A_b1, _A_b2, _A_b3);
+}
+
+/** Creates an adaptor of type sigc::bind_functor which fixes the last 4 argument(s) of the passed functor.
+ * This function overload fixes the last 4 argument(s) of @e _A_func.
+ *
+ * @param _A_func Functor that should be wrapped.
+ * @param _A_b1 Argument to bind to @e _A_func.
+ * @param _A_b2 Argument to bind to @e _A_func.
+ * @param _A_b3 Argument to bind to @e _A_func.
+ * @param _A_b4 Argument to bind to @e _A_func.
+ * @return Adaptor that executes _A_func with the bound argument on invokation.
+ *
+ * @ingroup bind
+ */
+template <class T_type1, class T_type2, class T_type3, class T_type4, class T_functor>
+inline bind_functor<-1, T_functor,
+ T_type1,
+ T_type2,
+ T_type3,
+ T_type4>
+bind(const T_functor& _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4)
+{ return bind_functor<-1, T_functor,
+ T_type1,
+ T_type2,
+ T_type3,
+ T_type4>
+ (_A_func, _A_b1, _A_b2, _A_b3, _A_b4);
+}
+
+/** Creates an adaptor of type sigc::bind_functor which fixes the last 5 argument(s) of the passed functor.
+ * This function overload fixes the last 5 argument(s) of @e _A_func.
+ *
+ * @param _A_func Functor that should be wrapped.
+ * @param _A_b1 Argument to bind to @e _A_func.
+ * @param _A_b2 Argument to bind to @e _A_func.
+ * @param _A_b3 Argument to bind to @e _A_func.
+ * @param _A_b4 Argument to bind to @e _A_func.
+ * @param _A_b5 Argument to bind to @e _A_func.
+ * @return Adaptor that executes _A_func with the bound argument on invokation.
+ *
+ * @ingroup bind
+ */
+template <class T_type1, class T_type2, class T_type3, class T_type4, class T_type5, class T_functor>
+inline bind_functor<-1, T_functor,
+ T_type1,
+ T_type2,
+ T_type3,
+ T_type4,
+ T_type5>
+bind(const T_functor& _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4, T_type5 _A_b5)
+{ return bind_functor<-1, T_functor,
+ T_type1,
+ T_type2,
+ T_type3,
+ T_type4,
+ T_type5>
+ (_A_func, _A_b1, _A_b2, _A_b3, _A_b4, _A_b5);
+}
+
+/** Creates an adaptor of type sigc::bind_functor which fixes the last 6 argument(s) of the passed functor.
+ * This function overload fixes the last 6 argument(s) of @e _A_func.
+ *
+ * @param _A_func Functor that should be wrapped.
+ * @param _A_b1 Argument to bind to @e _A_func.
+ * @param _A_b2 Argument to bind to @e _A_func.
+ * @param _A_b3 Argument to bind to @e _A_func.
+ * @param _A_b4 Argument to bind to @e _A_func.
+ * @param _A_b5 Argument to bind to @e _A_func.
+ * @param _A_b6 Argument to bind to @e _A_func.
+ * @return Adaptor that executes _A_func with the bound argument on invokation.
+ *
+ * @ingroup bind
+ */
+template <class T_type1, class T_type2, class T_type3, class T_type4, class T_type5, class T_type6, class T_functor>
+inline bind_functor<-1, T_functor,
+ T_type1,
+ T_type2,
+ T_type3,
+ T_type4,
+ T_type5,
+ T_type6>
+bind(const T_functor& _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4, T_type5 _A_b5, T_type6 _A_b6)
+{ return bind_functor<-1, T_functor,
+ T_type1,
+ T_type2,
+ T_type3,
+ T_type4,
+ T_type5,
+ T_type6>
+ (_A_func, _A_b1, _A_b2, _A_b3, _A_b4, _A_b5, _A_b6);
+}
+
+/** Creates an adaptor of type sigc::bind_functor which fixes the last 7 argument(s) of the passed functor.
+ * This function overload fixes the last 7 argument(s) of @e _A_func.
+ *
+ * @param _A_func Functor that should be wrapped.
+ * @param _A_b1 Argument to bind to @e _A_func.
+ * @param _A_b2 Argument to bind to @e _A_func.
+ * @param _A_b3 Argument to bind to @e _A_func.
+ * @param _A_b4 Argument to bind to @e _A_func.
+ * @param _A_b5 Argument to bind to @e _A_func.
+ * @param _A_b6 Argument to bind to @e _A_func.
+ * @param _A_b7 Argument to bind to @e _A_func.
+ * @return Adaptor that executes _A_func with the bound argument on invokation.
+ *
+ * @ingroup bind
+ */
+template <class T_type1, class T_type2, class T_type3, class T_type4, class T_type5, class T_type6, class T_type7, class T_functor>
+inline bind_functor<-1, T_functor,
+ T_type1,
+ T_type2,
+ T_type3,
+ T_type4,
+ T_type5,
+ T_type6,
+ T_type7>
+bind(const T_functor& _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4, T_type5 _A_b5, T_type6 _A_b6, T_type7 _A_b7)
+{ return bind_functor<-1, T_functor,
+ T_type1,
+ T_type2,
+ T_type3,
+ T_type4,
+ T_type5,
+ T_type6,
+ T_type7>
+ (_A_func, _A_b1, _A_b2, _A_b3, _A_b4, _A_b5, _A_b6, _A_b7);
+}
+
+
+} /* namespace sigc */
+
+#ifdef SIGC_NIL_HAS_BEEN_PUSHED
+ #undef SIGC_NIL_HAS_BEEN_PUSHED
+ #pragma pop_macro("nil")
+#endif
+#endif /* _SIGC_ADAPTORS_BIND_H_ */
--- /dev/null
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+#ifndef _SIGC_ADAPTORS_BIND_RETURN_H_
+#define _SIGC_ADAPTORS_BIND_RETURN_H_
+#include <sigc++/adaptors/adaptor_trait.h>
+#include <sigc++/adaptors/bound_argument.h>
+
+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 <class T_return, class T_functor>
+struct bind_return_functor : public adapts<T_functor>
+{
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef typename unwrap_reference<T_return>::type type; };
+#endif
+ typedef typename unwrap_reference<T_return>::type result_type;
+
+ /** Invokes the wrapped functor dropping its return value.
+ * @return The fixed return value.
+ */
+ typename unwrap_reference<T_return>::type operator()();
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @return The fixed return value.
+ */
+ template <class T_arg1>
+ inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1)
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>>
+ (_A_a1); return ret_value_.invoke();
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1>
+ inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1)
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>>
+ (_A_a1); return ret_value_.invoke();
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @return The fixed return value.
+ */
+ template <class T_arg1, class T_arg2>
+ inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1, T_arg2 _A_a2)
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>>
+ (_A_a1, _A_a2); return ret_value_.invoke();
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2>
+ inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2)
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>>
+ (_A_a1, _A_a2); return ret_value_.invoke();
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @return The fixed return value.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3>
+ inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
+ (_A_a1, _A_a2, _A_a3); return ret_value_.invoke();
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3>
+ inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
+ (_A_a1, _A_a2, _A_a3); return ret_value_.invoke();
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @return The fixed return value.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
+ (_A_a1, _A_a2, _A_a3, _A_a4); return ret_value_.invoke();
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
+ (_A_a1, _A_a2, _A_a3, _A_a4); return ret_value_.invoke();
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @param _A_a5 Argument to be passed on to the functor.
+ * @return The fixed return value.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); return ret_value_.invoke();
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); return ret_value_.invoke();
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @param _A_a5 Argument to be passed on to the functor.
+ * @param _A_a6 Argument to be passed on to the functor.
+ * @return The fixed return value.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); return ret_value_.invoke();
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); return ret_value_.invoke();
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @param _A_a5 Argument to be passed on to the functor.
+ * @param _A_a6 Argument to be passed on to the functor.
+ * @param _A_a7 Argument to be passed on to the functor.
+ * @return The fixed return value.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); return ret_value_.invoke();
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); return ret_value_.invoke();
+ }
+ #endif
+
+
+ /** 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(type_trait_take_t<T_functor> _A_functor, type_trait_take_t<T_return> _A_ret_value)
+ : adapts<T_functor>(_A_functor), ret_value_(_A_ret_value)
+ {}
+
+ /// The fixed return value.
+ bound_argument<T_return> ret_value_; // public, so that visit_each() can access it
+};
+
+template <class T_return, class T_functor>
+typename unwrap_reference<T_return>::type bind_return_functor<T_return, T_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 <class T_return, class T_functor>
+struct visitor<bind_return_functor<T_return, T_functor> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bind_return_functor<T_return, T_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 <class T_return, class T_functor>
+inline bind_return_functor<T_return, T_functor>
+bind_return(const T_functor& _A_functor, T_return _A_ret_value)
+{ return bind_return_functor<T_return, T_functor>(_A_functor, _A_ret_value); }
+
+} /* namespace sigc */
+#endif /* _SIGC_ADAPTORS_BIND_RETURN_H_ */
--- /dev/null
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+
+#ifndef _SIGC_ADAPTORS_COMPOSE_H_
+#define _SIGC_ADAPTORS_COMPOSE_H_
+#include <sigc++/adaptors/adaptor_trait.h>
+
+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<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 <class T_setter, class T_getter>
+struct compose1_functor : public adapts<T_setter>
+{
+ typedef typename adapts<T_setter>::adaptor_type adaptor_type;
+ typedef T_setter setter_type;
+ typedef T_getter getter_type;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+ template <class T_arg1 = void, class T_arg2 = void, class T_arg3 = void, class T_arg4 = void, class T_arg5 = void, class T_arg6 = void, class T_arg7 = void>
+ struct deduce_result_type
+ { typedef typename adaptor_type::template deduce_result_type<
+ sigc::deduce_result_t<T_getter, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+ >::type type; };
+#endif
+ typedef typename adaptor_type::result_type result_type;
+
+ result_type
+ operator()();
+
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ operator()(T_arg1 _A_a1)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<T_getter, T_arg1>>
+ (get_(_A_a1));
+ }
+
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<T_getter, T_arg1, T_arg2>>
+ (get_(_A_a1, _A_a2));
+ }
+
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<T_getter, T_arg1, T_arg2, T_arg3>>
+ (get_(_A_a1, _A_a2, _A_a3));
+ }
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<T_getter, T_arg1, T_arg2, T_arg3, T_arg4>>
+ (get_(_A_a1, _A_a2, _A_a3, _A_a4));
+ }
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<T_getter, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>>
+ (get_(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5));
+ }
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<T_getter, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>>
+ (get_(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6));
+ }
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<T_getter, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>>
+ (get_(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7));
+ }
+
+
+ /** 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<T_setter>(_A_setter), get_(_A_getter)
+ {}
+
+ getter_type get_; // public, so that visit_each() can access it
+};
+
+template <class T_setter, class T_getter>
+typename compose1_functor<T_setter, T_getter>::result_type
+compose1_functor<T_setter, T_getter>::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 <class T_setter, class T_getter1, class T_getter2>
+struct compose2_functor : public adapts<T_setter>
+{
+ typedef typename adapts<T_setter>::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 <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef typename adaptor_type::template deduce_result_type<
+ typename sigc::deduce_result_t<T_getter1, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>,
+ typename sigc::deduce_result_t<T_getter2, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+ >::type result_type; };
+#endif
+ typedef typename adaptor_type::result_type result_type;
+
+ result_type
+ operator()();
+
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ operator()(T_arg1 _A_a1)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<T_getter1, T_arg1>,
+ sigc::deduce_result_t<T_getter2, T_arg1>>
+ (get1_(_A_a1), get2_(_A_a1));
+ }
+
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<T_getter1, T_arg1, T_arg2>,
+ sigc::deduce_result_t<T_getter2, T_arg1, T_arg2>>
+ (get1_(_A_a1, _A_a2), get2_(_A_a1, _A_a2));
+ }
+
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<T_getter1, T_arg1, T_arg2, T_arg3>,
+ sigc::deduce_result_t<T_getter2, T_arg1, T_arg2, T_arg3>>
+ (get1_(_A_a1, _A_a2, _A_a3), get2_(_A_a1, _A_a2, _A_a3));
+ }
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<T_getter1, T_arg1, T_arg2, T_arg3, T_arg4>,
+ sigc::deduce_result_t<T_getter2, T_arg1, T_arg2, T_arg3, T_arg4>>
+ (get1_(_A_a1, _A_a2, _A_a3, _A_a4), get2_(_A_a1, _A_a2, _A_a3, _A_a4));
+ }
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<T_getter1, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>,
+ sigc::deduce_result_t<T_getter2, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>>
+ (get1_(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5), get2_(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5));
+ }
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<T_getter1, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>,
+ sigc::deduce_result_t<T_getter2, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>>
+ (get1_(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6), get2_(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6));
+ }
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<sigc::deduce_result_t<T_getter1, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>,
+ sigc::deduce_result_t<T_getter2, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>>
+ (get1_(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7), get2_(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7));
+ }
+
+
+ /** 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<T_setter>(_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 <class T_setter, class T_getter1, class T_getter2>
+typename compose2_functor<T_setter, T_getter1, T_getter2>::result_type
+compose2_functor<T_setter, T_getter1, T_getter2>::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 <class T_setter, class T_getter>
+struct visitor<compose1_functor<T_setter, T_getter> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const compose1_functor<T_setter, T_getter>& _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 <class T_setter, class T_getter1, class T_getter2>
+struct visitor<compose2_functor<T_setter, T_getter1, T_getter2> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const compose2_functor<T_setter, T_getter1, T_getter2>& _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 <class T_setter, class T_getter>
+inline compose1_functor<T_setter, T_getter>
+compose(const T_setter& _A_setter, const T_getter& _A_getter)
+ { return compose1_functor<T_setter, T_getter>(_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 <class T_setter, class T_getter1, class T_getter2>
+inline compose2_functor<T_setter, T_getter1, T_getter2>
+compose(const T_setter& _A_setter, const T_getter1& _A_getter1, const T_getter2& _A_getter2)
+ { return compose2_functor<T_setter, T_getter1, T_getter2>(_A_setter, _A_getter1, _A_getter2); }
+
+} /* namespace sigc */
+#endif /* _SIGC_ADAPTORS_COMPOSE_H_ */
--- /dev/null
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+/*
+*/
+#ifndef _SIGC_ADAPTORS_DEDUCE_RESULT_TYPE_H_
+#define _SIGC_ADAPTORS_DEDUCE_RESULT_TYPE_H_
+#include <sigc++/functors/functor_trait.h>
+
+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.
+ * <tt>typename deduce_result_type<functor_type, list of arg_types>::type</tt>
+ * 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
+ * <tt>typename deduce_result_type<functor_type, list of arg_types>::type</tt>
+ * to determine the return type of their <tt>templated operator()</tt> 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
+ * <tt>template operator()</tt> overload.
+ *
+ * @ingroup adaptors
+ */
+template<class T_functor, class... T_args>
+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<class U_functor, typename = typename std::is_base_of<adaptor_base, T_functor>::type>
+ static
+ typename U_functor::template deduce_result_type<T_args...>::type
+ test();
+
+ //Otherwise, the compiler will choose this fallback method.
+ template<class U_functor>
+ static
+ typename functor_trait<T_functor>::result_type
+ test();
+
+ using type = decltype (test<T_functor> ());
+};
+
+template<typename T_functor, typename... T_args>
+using deduce_result_t = typename deduce_result_type<T_functor, T_args...>::type;
+
+} /* namespace sigc */
+#endif /* _SIGC_ADAPTORS_DEDUCE_RESULT_TYPE_H_ */
--- /dev/null
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+#ifndef _SIGC_ADAPTORS_EXCEPTION_CATCH_H_
+#define _SIGC_ADAPTORS_EXCEPTION_CATCH_H_
+#include <sigc++/adaptors/adaptor_trait.h>
+
+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<int> some_signal;
+ * some_signal.connect(sigc::exception_catch(&foo, my_catch));
+ * @endcode
+ *
+ * @ingroup adaptors
+ */
+
+template <class T_functor, class T_catcher, class T_return = typename adapts<T_functor>::result_type>
+struct exception_catch_functor : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>::type type; };
+#endif
+ typedef T_return result_type;
+
+ result_type
+ operator()();
+
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ operator()(T_arg1 _A_a1)
+ {
+ try
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>>
+ (_A_a1);
+ }
+ catch (...)
+ { return catcher_(); }
+ }
+
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2)
+ {
+ try
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>>
+ (_A_a1, _A_a2);
+ }
+ catch (...)
+ { return catcher_(); }
+ }
+
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)
+ {
+ try
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
+ (_A_a1, _A_a2, _A_a3);
+ }
+ catch (...)
+ { return catcher_(); }
+ }
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
+ {
+ try
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
+ (_A_a1, _A_a2, _A_a3, _A_a4);
+ }
+ catch (...)
+ { return catcher_(); }
+ }
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
+ {
+ try
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5);
+ }
+ catch (...)
+ { return catcher_(); }
+ }
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
+ {
+ try
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6);
+ }
+ catch (...)
+ { return catcher_(); }
+ }
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
+ {
+ try
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7);
+ }
+ catch (...)
+ { return catcher_(); }
+ }
+
+ exception_catch_functor(const T_functor& _A_func,
+ const T_catcher& _A_catcher)
+ : adapts<T_functor>(_A_func), catcher_(_A_catcher)
+ {}
+
+ T_catcher catcher_;
+};
+
+template <class T_functor, class T_catcher, class T_return>
+typename exception_catch_functor<T_functor, T_catcher, T_return>::result_type
+exception_catch_functor<T_functor, T_catcher, T_return>::operator()()
+ {
+ try
+ { return this->functor_(); }
+ catch (...)
+ { return catcher_(); }
+ }
+
+// void specialization
+template <class T_functor, class T_catcher>
+struct exception_catch_functor<T_functor, T_catcher, void> : public adapts<T_functor>
+{
+ typedef void result_type;
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>::type type; };
+#endif
+
+ void
+ operator()();
+
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ operator()(T_arg1 _A_a1)
+ {
+ try
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>>
+ (_A_a1);
+ }
+ catch (...)
+ { return catcher_(); }
+ }
+
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2)
+ {
+ try
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>>
+ (_A_a1, _A_a2);
+ }
+ catch (...)
+ { return catcher_(); }
+ }
+
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)
+ {
+ try
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
+ (_A_a1, _A_a2, _A_a3);
+ }
+ catch (...)
+ { return catcher_(); }
+ }
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
+ {
+ try
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
+ (_A_a1, _A_a2, _A_a3, _A_a4);
+ }
+ catch (...)
+ { return catcher_(); }
+ }
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
+ {
+ try
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5);
+ }
+ catch (...)
+ { return catcher_(); }
+ }
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
+ {
+ try
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6);
+ }
+ catch (...)
+ { return catcher_(); }
+ }
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
+ {
+ try
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7);
+ }
+ catch (...)
+ { return catcher_(); }
+ }
+
+ exception_catch_functor() {}
+ exception_catch_functor(const T_functor& _A_func,
+ const T_catcher& _A_catcher)
+ : adapts<T_functor>(_A_func), catcher_(_A_catcher)
+ {}
+ ~exception_catch_functor() {}
+
+ T_catcher catcher_;
+};
+
+template <class T_functor, class T_catcher>
+void exception_catch_functor<T_functor, T_catcher, void>::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 <class T_functor, class T_catcher, class T_return>
+struct visitor<exception_catch_functor<T_functor, T_catcher, T_return> >
+{
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const exception_catch_functor<T_functor, T_catcher, T_return>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.functor_);
+ sigc::visit_each(_A_action, _A_target.catcher_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+template <class T_functor, class T_catcher>
+inline exception_catch_functor<T_functor, T_catcher>
+exception_catch(const T_functor& _A_func, const T_catcher& _A_catcher)
+ { return exception_catch_functor<T_functor, T_catcher>(_A_func, _A_catcher); }
+
+} /* namespace sigc */
+#endif /* _SIGC_ADAPTORS_EXCEPTION_CATCH_H_ */
--- /dev/null
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+#ifndef _SIGC_ADAPTORS_HIDE_H_
+#define _SIGC_ADAPTORS_HIDE_H_
+#include <sigc++/adaptors/adaptor_trait.h>
+
+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<void,int> 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 <int I_location, class T_functor>
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+struct hide_functor;
+#else
+struct hide_functor {};
+#endif
+
+/** Adaptor that adds a dummy parameter to the wrapped functor.
+ * This template specialization ignores the value of the last parameter in operator()().
+ *
+ * @ingroup hide
+ */
+template <class T_functor>
+struct hide_functor <-1, T_functor> : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>::type type; };
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+ typedef typename adaptor_type::result_type result_type;
+
+ /** Invokes the wrapped functor ignoring the only argument.
+ * @param _A_a1 Argument to be ignored.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ operator()(T_arg1)
+ { return this->functor_(); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ sun_forte_workaround(T_arg1 _A_a1)
+ { return this->functor_(); }
+ #endif
+
+ /** Invokes the wrapped functor, ignoring the last argument.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be ignored.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ operator()(T_arg1 _A_a1, T_arg2)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>>
+ (_A_a1); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>>
+ (_A_a1); }
+ #endif
+
+ /** Invokes the wrapped functor, ignoring the last argument.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be ignored.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>>
+ (_A_a1, _A_a2); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>>
+ (_A_a1, _A_a2); }
+ #endif
+
+ /** Invokes the wrapped functor, ignoring the last argument.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be ignored.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
+ (_A_a1, _A_a2, _A_a3); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
+ (_A_a1, _A_a2, _A_a3); }
+ #endif
+
+ /** Invokes the wrapped functor, ignoring the last argument.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @param _A_a5 Argument to be ignored.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
+ (_A_a1, _A_a2, _A_a3, _A_a4); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
+ (_A_a1, _A_a2, _A_a3, _A_a4); }
+ #endif
+
+ /** Invokes the wrapped functor, ignoring the last argument.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @param _A_a5 Argument to be passed on to the functor.
+ * @param _A_a6 Argument to be ignored.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
+ #endif
+
+ /** Invokes the wrapped functor, ignoring the last argument.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @param _A_a5 Argument to be passed on to the functor.
+ * @param _A_a6 Argument to be passed on to the functor.
+ * @param _A_a7 Argument to be ignored.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
+ #endif
+
+
+ /** 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<T_functor>(_A_func)
+ {}
+};
+
+/** Adaptor that adds a dummy parameter to the wrapped functor.
+ * This template specialization ignores the value of the 1st parameter in operator()().
+ *
+ * @ingroup hide
+ */
+template <class T_functor>
+struct hide_functor <0, T_functor> : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>::type type; };
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+ typedef typename adaptor_type::result_type result_type;
+
+ /** Invokes the wrapped functor ignoring the only argument.
+ * @param _A_a1 Argument to be ignored.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ operator()(T_arg1)
+ { return this->functor_(); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ sun_forte_workaround(T_arg1 _A_a1)
+ { return this->functor_(); }
+ #endif
+
+ /** Invokes the wrapped functor, ignoring the 1st argument.
+ * @param _A_a1 Argument to be ignored.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ operator()(T_arg1, T_arg2 _A_a2)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg2>>
+ (_A_a2); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ sun_forte_workaround(T_arg1, T_arg2 _A_a2)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg2>>
+ (_A_a2); }
+ #endif
+
+ /** Invokes the wrapped functor, ignoring the 1st argument.
+ * @param _A_a1 Argument to be ignored.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ operator()(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
+ (_A_a2, _A_a3); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ sun_forte_workaround(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
+ (_A_a2, _A_a3); }
+ #endif
+
+ /** Invokes the wrapped functor, ignoring the 1st argument.
+ * @param _A_a1 Argument to be ignored.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ operator()(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
+ (_A_a2, _A_a3, _A_a4); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ sun_forte_workaround(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
+ (_A_a2, _A_a3, _A_a4); }
+ #endif
+
+ /** Invokes the wrapped functor, ignoring the 1st argument.
+ * @param _A_a1 Argument to be ignored.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @param _A_a5 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ operator()(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
+ (_A_a2, _A_a3, _A_a4, _A_a5); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ sun_forte_workaround(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
+ (_A_a2, _A_a3, _A_a4, _A_a5); }
+ #endif
+
+ /** Invokes the wrapped functor, ignoring the 1st argument.
+ * @param _A_a1 Argument to be ignored.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @param _A_a5 Argument to be passed on to the functor.
+ * @param _A_a6 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ operator()(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ sun_forte_workaround(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
+ #endif
+
+ /** Invokes the wrapped functor, ignoring the 1st argument.
+ * @param _A_a1 Argument to be ignored.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @param _A_a5 Argument to be passed on to the functor.
+ * @param _A_a6 Argument to be passed on to the functor.
+ * @param _A_a7 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
+ operator()(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>
+ (_A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
+ sun_forte_workaround(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>
+ (_A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
+ #endif
+
+
+ /** 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<T_functor>(_A_func)
+ {}
+};
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+/** Adaptor that adds a dummy parameter to the wrapped functor.
+ * This template specialization ignores the value of the 2nd parameter in operator()().
+ *
+ * @ingroup hide
+ */
+template <class T_functor>
+struct hide_functor <1, T_functor> : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>::type type; };
+ typedef typename adaptor_type::result_type result_type;
+
+ /** Invokes the wrapped functor, ignoring the 2nd argument.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be ignored.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ operator()(T_arg1 _A_a1, T_arg2)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>>
+ (_A_a1); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>>
+ (_A_a1); }
+ #endif
+
+ /** Invokes the wrapped functor, ignoring the 2nd argument.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be ignored.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ operator()(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg3>>
+ (_A_a1, _A_a3); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg3>>
+ (_A_a1, _A_a3); }
+ #endif
+
+ /** Invokes the wrapped functor, ignoring the 2nd argument.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be ignored.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ operator()(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
+ (_A_a1, _A_a3, _A_a4); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
+ (_A_a1, _A_a3, _A_a4); }
+ #endif
+
+ /** Invokes the wrapped functor, ignoring the 2nd argument.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be ignored.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @param _A_a5 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ operator()(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
+ (_A_a1, _A_a3, _A_a4, _A_a5); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
+ (_A_a1, _A_a3, _A_a4, _A_a5); }
+ #endif
+
+ /** Invokes the wrapped functor, ignoring the 2nd argument.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be ignored.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @param _A_a5 Argument to be passed on to the functor.
+ * @param _A_a6 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ operator()(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_a1, _A_a3, _A_a4, _A_a5, _A_a6); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_a1, _A_a3, _A_a4, _A_a5, _A_a6); }
+ #endif
+
+ /** Invokes the wrapped functor, ignoring the 2nd argument.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be ignored.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @param _A_a5 Argument to be passed on to the functor.
+ * @param _A_a6 Argument to be passed on to the functor.
+ * @param _A_a7 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
+ operator()(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>
+ (_A_a1, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>
+ (_A_a1, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
+ #endif
+
+
+ /** 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<T_functor>(_A_func)
+ {}
+};
+
+/** Adaptor that adds a dummy parameter to the wrapped functor.
+ * This template specialization ignores the value of the 3rd parameter in operator()().
+ *
+ * @ingroup hide
+ */
+template <class T_functor>
+struct hide_functor <2, T_functor> : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>::type type; };
+ typedef typename adaptor_type::result_type result_type;
+
+ /** Invokes the wrapped functor, ignoring the 3rd argument.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be ignored.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>>
+ (_A_a1, _A_a2); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>>
+ (_A_a1, _A_a2); }
+ #endif
+
+ /** Invokes the wrapped functor, ignoring the 3rd argument.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be ignored.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg4>>
+ (_A_a1, _A_a2, _A_a4); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg4>>
+ (_A_a1, _A_a2, _A_a4); }
+ #endif
+
+ /** Invokes the wrapped functor, ignoring the 3rd argument.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be ignored.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @param _A_a5 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
+ (_A_a1, _A_a2, _A_a4, _A_a5); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
+ (_A_a1, _A_a2, _A_a4, _A_a5); }
+ #endif
+
+ /** Invokes the wrapped functor, ignoring the 3rd argument.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be ignored.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @param _A_a5 Argument to be passed on to the functor.
+ * @param _A_a6 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_a1, _A_a2, _A_a4, _A_a5, _A_a6); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_a1, _A_a2, _A_a4, _A_a5, _A_a6); }
+ #endif
+
+ /** Invokes the wrapped functor, ignoring the 3rd argument.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be ignored.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @param _A_a5 Argument to be passed on to the functor.
+ * @param _A_a6 Argument to be passed on to the functor.
+ * @param _A_a7 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>
+ (_A_a1, _A_a2, _A_a4, _A_a5, _A_a6, _A_a7); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>
+ (_A_a1, _A_a2, _A_a4, _A_a5, _A_a6, _A_a7); }
+ #endif
+
+
+ /** 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<T_functor>(_A_func)
+ {}
+};
+
+/** Adaptor that adds a dummy parameter to the wrapped functor.
+ * This template specialization ignores the value of the 4th parameter in operator()().
+ *
+ * @ingroup hide
+ */
+template <class T_functor>
+struct hide_functor <3, T_functor> : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>::type type; };
+ typedef typename adaptor_type::result_type result_type;
+
+ /** Invokes the wrapped functor, ignoring the 4th argument.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be ignored.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
+ (_A_a1, _A_a2, _A_a3); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
+ (_A_a1, _A_a2, _A_a3); }
+ #endif
+
+ /** Invokes the wrapped functor, ignoring the 4th argument.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be ignored.
+ * @param _A_a5 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg5>>
+ (_A_a1, _A_a2, _A_a3, _A_a5); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg5>>
+ (_A_a1, _A_a2, _A_a3, _A_a5); }
+ #endif
+
+ /** Invokes the wrapped functor, ignoring the 4th argument.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be ignored.
+ * @param _A_a5 Argument to be passed on to the functor.
+ * @param _A_a6 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5, T_arg6 _A_a6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_a1, _A_a2, _A_a3, _A_a5, _A_a6); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5, T_arg6 _A_a6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_a1, _A_a2, _A_a3, _A_a5, _A_a6); }
+ #endif
+
+ /** Invokes the wrapped functor, ignoring the 4th argument.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be ignored.
+ * @param _A_a5 Argument to be passed on to the functor.
+ * @param _A_a6 Argument to be passed on to the functor.
+ * @param _A_a7 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>
+ (_A_a1, _A_a2, _A_a3, _A_a5, _A_a6, _A_a7); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>
+ (_A_a1, _A_a2, _A_a3, _A_a5, _A_a6, _A_a7); }
+ #endif
+
+
+ /** 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<T_functor>(_A_func)
+ {}
+};
+
+/** Adaptor that adds a dummy parameter to the wrapped functor.
+ * This template specialization ignores the value of the 5th parameter in operator()().
+ *
+ * @ingroup hide
+ */
+template <class T_functor>
+struct hide_functor <4, T_functor> : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>::type type; };
+ typedef typename adaptor_type::result_type result_type;
+
+ /** Invokes the wrapped functor, ignoring the 5th argument.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @param _A_a5 Argument to be ignored.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
+ (_A_a1, _A_a2, _A_a3, _A_a4); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
+ (_A_a1, _A_a2, _A_a3, _A_a4); }
+ #endif
+
+ /** Invokes the wrapped functor, ignoring the 5th argument.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @param _A_a5 Argument to be ignored.
+ * @param _A_a6 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5, T_arg6 _A_a6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg6>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a6); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5, T_arg6 _A_a6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg6>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a6); }
+ #endif
+
+ /** Invokes the wrapped functor, ignoring the 5th argument.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @param _A_a5 Argument to be ignored.
+ * @param _A_a6 Argument to be passed on to the functor.
+ * @param _A_a7 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5, T_arg6 _A_a6, T_arg7 _A_a7)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a6, _A_a7); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5, T_arg6 _A_a6, T_arg7 _A_a7)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a6, _A_a7); }
+ #endif
+
+
+ /** 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<T_functor>(_A_func)
+ {}
+};
+
+/** Adaptor that adds a dummy parameter to the wrapped functor.
+ * This template specialization ignores the value of the 6th parameter in operator()().
+ *
+ * @ingroup hide
+ */
+template <class T_functor>
+struct hide_functor <5, T_functor> : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg7>>::type type; };
+ typedef typename adaptor_type::result_type result_type;
+
+ /** Invokes the wrapped functor, ignoring the 6th argument.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @param _A_a5 Argument to be passed on to the functor.
+ * @param _A_a6 Argument to be ignored.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
+ #endif
+
+ /** Invokes the wrapped functor, ignoring the 6th argument.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @param _A_a5 Argument to be passed on to the functor.
+ * @param _A_a6 Argument to be ignored.
+ * @param _A_a7 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6, T_arg7 _A_a7)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg7>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a7); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6, T_arg7 _A_a7)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg7>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a7); }
+ #endif
+
+
+ /** 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<T_functor>(_A_func)
+ {}
+};
+
+/** Adaptor that adds a dummy parameter to the wrapped functor.
+ * This template specialization ignores the value of the 7th parameter in operator()().
+ *
+ * @ingroup hide
+ */
+template <class T_functor>
+struct hide_functor <6, T_functor> : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>::type type; };
+ typedef typename adaptor_type::result_type result_type;
+
+ /** Invokes the wrapped functor, ignoring the 7th argument.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @param _A_a5 Argument to be passed on to the functor.
+ * @param _A_a6 Argument to be passed on to the functor.
+ * @param _A_a7 Argument to be ignored.
+ * @return The return value of the functor invocation.
+ */
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
+ #endif
+
+
+ /** 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<T_functor>(_A_func)
+ {}
+};
+#endif // DOXYGEN_SHOULD_SKIP_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 overload for sigc::hide_functor performs a functor on the
+ * functor stored in the sigc::hide_functor object.
+ *
+ * @ingroup hide
+ */
+template <int I_location, class T_functor>
+struct visitor<hide_functor<I_location, T_functor> >
+{
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const hide_functor<I_location, T_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 <int I_location, class T_functor>
+inline hide_functor<I_location, T_functor>
+hide(const T_functor& _A_func)
+ { return hide_functor<I_location, T_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 <class T_functor>
+inline hide_functor<-1, T_functor>
+hide(const T_functor& _A_func)
+ { return hide_functor<-1, T_functor> (_A_func); }
+
+} /* namespace sigc */
+#endif /* _SIGC_ADAPTORS_HIDE_H_ */
--- /dev/null
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+#ifndef _SIGC_LAMBDA_BASE_HPP_
+#define _SIGC_LAMBDA_BASE_HPP_
+#include <sigc++/adaptors/adaptor_trait.h>
+#include <sigc++/reference_wrapper.h>
+#include <type_traits>
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+
+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 <class T_type> 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 <class T_type, bool I_islambda = std::is_base_of<lambda_base, T_type>::value> struct lambda_core;
+
+/** Abstracts lambda functionality (template specialization for lambda values).
+ *
+ * @deprecated Use C++11 lambda expressions instead.
+ *
+ * @ingroup lambdas
+ */
+template <class T_type>
+struct lambda_core<T_type, true> : public lambda_base
+{
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef typename T_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>::type type; };
+ typedef typename T_type::result_type result_type;
+ typedef T_type lambda_type;
+
+ result_type
+ operator()() const;
+
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ operator ()(T_arg1 _A_1) const
+ { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>>
+ (_A_1);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ sun_forte_workaround(T_arg1 _A_1) const
+ { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>>
+ (_A_1);
+ }
+ #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ operator ()(T_arg1 _A_1, T_arg2 _A_2) const
+ { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>>
+ (_A_1, _A_2);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2) const
+ { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>>
+ (_A_1, _A_2);
+ }
+ #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ operator ()(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3) const
+ { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
+ (_A_1, _A_2, _A_3);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3) const
+ { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
+ (_A_1, _A_2, _A_3);
+ }
+ #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ operator ()(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4) const
+ { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
+ (_A_1, _A_2, _A_3, _A_4);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4) const
+ { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
+ (_A_1, _A_2, _A_3, _A_4);
+ }
+ #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ operator ()(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5) const
+ { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
+ (_A_1, _A_2, _A_3, _A_4, _A_5);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5) const
+ { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
+ (_A_1, _A_2, _A_3, _A_4, _A_5);
+ }
+ #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ operator ()(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5, T_arg6 _A_6) const
+ { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_1, _A_2, _A_3, _A_4, _A_5, _A_6);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5, T_arg6 _A_6) const
+ { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_1, _A_2, _A_3, _A_4, _A_5, _A_6);
+ }
+ #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
+ operator ()(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5, T_arg6 _A_6, T_arg7 _A_7) const
+ { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>
+ (_A_1, _A_2, _A_3, _A_4, _A_5, _A_6, _A_7);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
+ sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5, T_arg6 _A_6, T_arg7 _A_7) const
+ { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>
+ (_A_1, _A_2, _A_3, _A_4, _A_5, _A_6, _A_7);
+ }
+ #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+ lambda_core() {}
+
+ explicit lambda_core(const T_type& v)
+ : value_(v) {}
+
+ T_type value_;
+};
+
+
+} /* namespace internal */
+
+
+// forward declarations for lambda operators other<subscript> and other<assign>
+template <class T_type>
+struct other;
+struct subscript;
+struct assign;
+
+template <class T_action, class T_type1, class T_type2>
+struct lambda_operator;
+
+template <class T_type>
+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 <class T_type>
+struct lambda : public internal::lambda_core<T_type>
+{
+ typedef lambda<T_type> self;
+
+ lambda()
+ {}
+
+ lambda(typename type_trait<T_type>::take v)
+ : internal::lambda_core<T_type>(v)
+ {}
+
+ // operators for other<subscript>
+ template <class T_arg>
+ lambda<lambda_operator<other<subscript>, self, typename unwrap_lambda_type<T_arg>::type> >
+ operator [] (const T_arg& a) const
+ { typedef lambda_operator<other<subscript>, self, typename unwrap_lambda_type<T_arg>::type> lambda_operator_type;
+ return lambda<lambda_operator_type>(lambda_operator_type(this->value_, unwrap_lambda_value(a))); }
+
+ // operators for other<assign>
+ template <class T_arg>
+ lambda<lambda_operator<other<assign>, self, typename unwrap_lambda_type<T_arg>::type> >
+ operator = (const T_arg& a) const
+ { typedef lambda_operator<other<assign>, self, typename unwrap_lambda_type<T_arg>::type> lambda_operator_type;
+ return lambda<lambda_operator_type>(lambda_operator_type(this->value_, unwrap_lambda_value(a))); }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+} /* namespace sigc */
+
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+#endif /* _SIGC_LAMBDA_BASE_HPP_ */
--- /dev/null
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+#include <sigc++/adaptors/lambda/select.h>
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+
+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.
+extern SIGC_API const lambda<internal::lambda_select1> _1;
+extern SIGC_API const lambda<internal::lambda_select2> _2;
+extern SIGC_API const lambda<internal::lambda_select3> _3;
+extern SIGC_API const lambda<internal::lambda_select4> _4;
+extern SIGC_API const lambda<internal::lambda_select5> _5;
+extern SIGC_API const lambda<internal::lambda_select6> _6;
+extern SIGC_API const lambda<internal::lambda_select7> _7;
+
+const lambda<internal::lambda_select1> _1;
+const lambda<internal::lambda_select2> _2;
+const lambda<internal::lambda_select3> _3;
+const lambda<internal::lambda_select4> _4;
+const lambda<internal::lambda_select5> _5;
+const lambda<internal::lambda_select6> _6;
+const lambda<internal::lambda_select7> _7;
+
+} /* namespace sigc */
+
+#endif // SIGCXX_DISABLE_DEPRECATED
--- /dev/null
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+#ifndef _SIGC_LAMBDA_SELECT_HPP_
+#define _SIGC_LAMBDA_SELECT_HPP_
+#include <sigc++/adaptors/lambda/base.h>
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+
+namespace sigc {
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace internal {
+struct lambda_select1 : public lambda_base
+{
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef T_arg1 type; };
+ typedef void result_type; // no operator ()() overload
+
+ void operator ()() const; // not implemented
+ template <class T_arg1>
+ T_arg1 operator ()(T_arg1 _A_1) const { return _A_1; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1>
+ //Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1) const { return operator()( _A_1 ); }
+ T_arg1 sun_forte_workaround(T_arg1 _A_1) const { return _A_1; }
+ #endif
+
+ template <class T_arg1, class T_arg2>
+ T_arg1 operator ()(T_arg1 _A_1, T_arg2) const { return _A_1; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2>
+ //Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2) const { return operator()( _A_1, _A_2 ); }
+ T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2) const { return _A_1; }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3>
+ T_arg1 operator ()(T_arg1 _A_1, T_arg2, T_arg3) const { return _A_1; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3>
+ //Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3) const { return operator()( _A_1, _A_2, _A_3 ); }
+ T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2, T_arg3) const { return _A_1; }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ T_arg1 operator ()(T_arg1 _A_1, T_arg2, T_arg3, T_arg4) const { return _A_1; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ //Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4) const { return operator()( _A_1, _A_2, _A_3, _A_4 ); }
+ T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2, T_arg3, T_arg4) const { return _A_1; }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ T_arg1 operator ()(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5) const { return _A_1; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ //Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5) const { return operator()( _A_1, _A_2, _A_3, _A_4, _A_5 ); }
+ T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5) const { return _A_1; }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ T_arg1 operator ()(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const { return _A_1; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ //Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5, T_arg6 _A_6) const { return operator()( _A_1, _A_2, _A_3, _A_4, _A_5, _A_6 ); }
+ T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const { return _A_1; }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ T_arg1 operator ()(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_1; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ //Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5, T_arg6 _A_6, T_arg7 _A_7) const { return operator()( _A_1, _A_2, _A_3, _A_4, _A_5, _A_6, _A_7 ); }
+ T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_1; }
+ #endif
+
+};
+
+struct lambda_select2 : public lambda_base
+{
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef T_arg2 type; };
+ typedef void result_type; // no operator ()() overload
+
+ void operator ()() const; // not implemented
+ template <class T_arg1, class T_arg2>
+ T_arg2 operator ()(T_arg1, T_arg2 _A_2) const { return _A_2; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2>
+ //Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2) const { return operator()( _A_1, _A_2 ); }
+ T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2) const { return _A_2; }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3>
+ T_arg2 operator ()(T_arg1, T_arg2 _A_2, T_arg3) const { return _A_2; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3>
+ //Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3) const { return operator()( _A_1, _A_2, _A_3 ); }
+ T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2, T_arg3) const { return _A_2; }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ T_arg2 operator ()(T_arg1, T_arg2 _A_2, T_arg3, T_arg4) const { return _A_2; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ //Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4) const { return operator()( _A_1, _A_2, _A_3, _A_4 ); }
+ T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2, T_arg3, T_arg4) const { return _A_2; }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ T_arg2 operator ()(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5) const { return _A_2; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ //Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5) const { return operator()( _A_1, _A_2, _A_3, _A_4, _A_5 ); }
+ T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5) const { return _A_2; }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ T_arg2 operator ()(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5, T_arg6) const { return _A_2; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ //Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5, T_arg6 _A_6) const { return operator()( _A_1, _A_2, _A_3, _A_4, _A_5, _A_6 ); }
+ T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5, T_arg6) const { return _A_2; }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ T_arg2 operator ()(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_2; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ //Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5, T_arg6 _A_6, T_arg7 _A_7) const { return operator()( _A_1, _A_2, _A_3, _A_4, _A_5, _A_6, _A_7 ); }
+ T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_2; }
+ #endif
+
+};
+
+struct lambda_select3 : public lambda_base
+{
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef T_arg3 type; };
+ typedef void result_type; // no operator ()() overload
+
+ void operator ()() const; // not implemented
+ template <class T_arg1, class T_arg2, class T_arg3>
+ T_arg3 operator ()(T_arg1, T_arg2, T_arg3 _A_3) const { return _A_3; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3>
+ //Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3) const { return operator()( _A_1, _A_2, _A_3 ); }
+ T_arg3 sun_forte_workaround(T_arg1, T_arg2, T_arg3 _A_3) const { return _A_3; }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ T_arg3 operator ()(T_arg1, T_arg2, T_arg3 _A_3, T_arg4) const { return _A_3; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ //Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4) const { return operator()( _A_1, _A_2, _A_3, _A_4 ); }
+ T_arg3 sun_forte_workaround(T_arg1, T_arg2, T_arg3 _A_3, T_arg4) const { return _A_3; }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ T_arg3 operator ()(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5) const { return _A_3; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ //Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5) const { return operator()( _A_1, _A_2, _A_3, _A_4, _A_5 ); }
+ T_arg3 sun_forte_workaround(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5) const { return _A_3; }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ T_arg3 operator ()(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5, T_arg6) const { return _A_3; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ //Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5, T_arg6 _A_6) const { return operator()( _A_1, _A_2, _A_3, _A_4, _A_5, _A_6 ); }
+ T_arg3 sun_forte_workaround(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5, T_arg6) const { return _A_3; }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ T_arg3 operator ()(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_3; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ //Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5, T_arg6 _A_6, T_arg7 _A_7) const { return operator()( _A_1, _A_2, _A_3, _A_4, _A_5, _A_6, _A_7 ); }
+ T_arg3 sun_forte_workaround(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_3; }
+ #endif
+
+};
+
+struct lambda_select4 : public lambda_base
+{
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef T_arg4 type; };
+ typedef void result_type; // no operator ()() overload
+
+ void operator ()() const; // not implemented
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ T_arg4 operator ()(T_arg1, T_arg2, T_arg3, T_arg4 _A_4) const { return _A_4; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ //Does not work: T_arg4 sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4) const { return operator()( _A_1, _A_2, _A_3, _A_4 ); }
+ T_arg4 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4 _A_4) const { return _A_4; }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ T_arg4 operator ()(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5) const { return _A_4; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ //Does not work: T_arg4 sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5) const { return operator()( _A_1, _A_2, _A_3, _A_4, _A_5 ); }
+ T_arg4 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5) const { return _A_4; }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ T_arg4 operator ()(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5, T_arg6) const { return _A_4; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ //Does not work: T_arg4 sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5, T_arg6 _A_6) const { return operator()( _A_1, _A_2, _A_3, _A_4, _A_5, _A_6 ); }
+ T_arg4 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5, T_arg6) const { return _A_4; }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ T_arg4 operator ()(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5, T_arg6, T_arg7) const { return _A_4; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ //Does not work: T_arg4 sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5, T_arg6 _A_6, T_arg7 _A_7) const { return operator()( _A_1, _A_2, _A_3, _A_4, _A_5, _A_6, _A_7 ); }
+ T_arg4 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5, T_arg6, T_arg7) const { return _A_4; }
+ #endif
+
+};
+
+struct lambda_select5 : public lambda_base
+{
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef T_arg5 type; };
+ typedef void result_type; // no operator ()() overload
+
+ void operator ()() const; // not implemented
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ T_arg5 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5) const { return _A_5; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ //Does not work: T_arg5 sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5) const { return operator()( _A_1, _A_2, _A_3, _A_4, _A_5 ); }
+ T_arg5 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5) const { return _A_5; }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ T_arg5 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5, T_arg6) const { return _A_5; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ //Does not work: T_arg5 sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5, T_arg6 _A_6) const { return operator()( _A_1, _A_2, _A_3, _A_4, _A_5, _A_6 ); }
+ T_arg5 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5, T_arg6) const { return _A_5; }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ T_arg5 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5, T_arg6, T_arg7) const { return _A_5; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ //Does not work: T_arg5 sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5, T_arg6 _A_6, T_arg7 _A_7) const { return operator()( _A_1, _A_2, _A_3, _A_4, _A_5, _A_6, _A_7 ); }
+ T_arg5 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5, T_arg6, T_arg7) const { return _A_5; }
+ #endif
+
+};
+
+struct lambda_select6 : public lambda_base
+{
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef T_arg6 type; };
+ typedef void result_type; // no operator ()() overload
+
+ void operator ()() const; // not implemented
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ T_arg6 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 _A_6) const { return _A_6; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ //Does not work: T_arg6 sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5, T_arg6 _A_6) const { return operator()( _A_1, _A_2, _A_3, _A_4, _A_5, _A_6 ); }
+ T_arg6 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 _A_6) const { return _A_6; }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ T_arg6 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 _A_6, T_arg7) const { return _A_6; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ //Does not work: T_arg6 sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5, T_arg6 _A_6, T_arg7 _A_7) const { return operator()( _A_1, _A_2, _A_3, _A_4, _A_5, _A_6, _A_7 ); }
+ T_arg6 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 _A_6, T_arg7) const { return _A_6; }
+ #endif
+
+};
+
+struct lambda_select7 : public lambda_base
+{
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef T_arg7 type; };
+ typedef void result_type; // no operator ()() overload
+
+ void operator ()() const; // not implemented
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ T_arg7 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 _A_7) const { return _A_7; }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ //Does not work: T_arg7 sun_forte_workaround(T_arg1 _A_1, T_arg2 _A_2, T_arg3 _A_3, T_arg4 _A_4, T_arg5 _A_5, T_arg6 _A_6, T_arg7 _A_7) const { return operator()( _A_1, _A_2, _A_3, _A_4, _A_5, _A_6, _A_7 ); }
+ T_arg7 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 _A_7) const { return _A_7; }
+ #endif
+
+};
+
+} /* namespace internal */
+
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+} /* namespace sigc */
+
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+#endif /* _SIGC_LAMBDA_SELECT_HPP_ */
--- /dev/null
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+#ifndef _SIGC_ADAPTORS_RETYPE_H_
+#define _SIGC_ADAPTORS_RETYPE_H_
+#include <sigc++/adaptors/adaptor_trait.h>
+#include <sigc++/functors/ptr_fun.h>
+#include <sigc++/functors/mem_fun.h>
+#include <sigc++/functors/slot.h>
+
+//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<void,float> 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<int>(&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_type1 Type of @e T_functor's 1th argument.
+ * - @e T_type2 Type of @e T_functor's 2th argument.
+ * - @e T_type3 Type of @e T_functor's 3th argument.
+ * - @e T_type4 Type of @e T_functor's 4th argument.
+ * - @e T_type5 Type of @e T_functor's 5th argument.
+ * - @e T_type6 Type of @e T_functor's 6th argument.
+ * - @e T_type7 Type of @e T_functor's 7th argument.
+ *
+ * @ingroup retype
+ */
+template <class T_functor, class T_type1=nil, class T_type2=nil, class T_type3=nil, class T_type4=nil, class T_type5=nil, class T_type6=nil, class T_type7=nil>
+struct retype_functor
+ : public adapts<T_functor>
+{
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>::type type; };
+#endif
+ typedef typename adapts<T_functor>::result_type result_type;
+
+ result_type operator()();
+
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ operator()(T_arg1 _A_a1)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_type1>>
+ (static_cast<T_type1>(_A_a1));
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ sun_forte_workaround(T_arg1 _A_a1)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_type1>>
+ (static_cast<T_type1>(_A_a1));
+ }
+ #endif
+
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_type1>, type_trait_take_t<T_type2>>
+ (static_cast<T_type1>(_A_a1), static_cast<T_type2>(_A_a2));
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_type1>, type_trait_take_t<T_type2>>
+ (static_cast<T_type1>(_A_a1), static_cast<T_type2>(_A_a2));
+ }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_type1>, type_trait_take_t<T_type2>, type_trait_take_t<T_type3>>
+ (static_cast<T_type1>(_A_a1), static_cast<T_type2>(_A_a2), static_cast<T_type3>(_A_a3));
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_type1>, type_trait_take_t<T_type2>, type_trait_take_t<T_type3>>
+ (static_cast<T_type1>(_A_a1), static_cast<T_type2>(_A_a2), static_cast<T_type3>(_A_a3));
+ }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_type1>, type_trait_take_t<T_type2>, type_trait_take_t<T_type3>, type_trait_take_t<T_type4>>
+ (static_cast<T_type1>(_A_a1), static_cast<T_type2>(_A_a2), static_cast<T_type3>(_A_a3), static_cast<T_type4>(_A_a4));
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_type1>, type_trait_take_t<T_type2>, type_trait_take_t<T_type3>, type_trait_take_t<T_type4>>
+ (static_cast<T_type1>(_A_a1), static_cast<T_type2>(_A_a2), static_cast<T_type3>(_A_a3), static_cast<T_type4>(_A_a4));
+ }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_type1>, type_trait_take_t<T_type2>, type_trait_take_t<T_type3>, type_trait_take_t<T_type4>, type_trait_take_t<T_type5>>
+ (static_cast<T_type1>(_A_a1), static_cast<T_type2>(_A_a2), static_cast<T_type3>(_A_a3), static_cast<T_type4>(_A_a4), static_cast<T_type5>(_A_a5));
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_type1>, type_trait_take_t<T_type2>, type_trait_take_t<T_type3>, type_trait_take_t<T_type4>, type_trait_take_t<T_type5>>
+ (static_cast<T_type1>(_A_a1), static_cast<T_type2>(_A_a2), static_cast<T_type3>(_A_a3), static_cast<T_type4>(_A_a4), static_cast<T_type5>(_A_a5));
+ }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_type1>, type_trait_take_t<T_type2>, type_trait_take_t<T_type3>, type_trait_take_t<T_type4>, type_trait_take_t<T_type5>, type_trait_take_t<T_type6>>
+ (static_cast<T_type1>(_A_a1), static_cast<T_type2>(_A_a2), static_cast<T_type3>(_A_a3), static_cast<T_type4>(_A_a4), static_cast<T_type5>(_A_a5), static_cast<T_type6>(_A_a6));
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_type1>, type_trait_take_t<T_type2>, type_trait_take_t<T_type3>, type_trait_take_t<T_type4>, type_trait_take_t<T_type5>, type_trait_take_t<T_type6>>
+ (static_cast<T_type1>(_A_a1), static_cast<T_type2>(_A_a2), static_cast<T_type3>(_A_a3), static_cast<T_type4>(_A_a4), static_cast<T_type5>(_A_a5), static_cast<T_type6>(_A_a6));
+ }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_type1>, type_trait_take_t<T_type2>, type_trait_take_t<T_type3>, type_trait_take_t<T_type4>, type_trait_take_t<T_type5>, type_trait_take_t<T_type6>, type_trait_take_t<T_type7>>
+ (static_cast<T_type1>(_A_a1), static_cast<T_type2>(_A_a2), static_cast<T_type3>(_A_a3), static_cast<T_type4>(_A_a4), static_cast<T_type5>(_A_a5), static_cast<T_type6>(_A_a6), static_cast<T_type7>(_A_a7));
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_type1>, type_trait_take_t<T_type2>, type_trait_take_t<T_type3>, type_trait_take_t<T_type4>, type_trait_take_t<T_type5>, type_trait_take_t<T_type6>, type_trait_take_t<T_type7>>
+ (static_cast<T_type1>(_A_a1), static_cast<T_type2>(_A_a2), static_cast<T_type3>(_A_a3), static_cast<T_type4>(_A_a4), static_cast<T_type5>(_A_a5), static_cast<T_type6>(_A_a6), static_cast<T_type7>(_A_a7));
+ }
+ #endif
+
+
+ /** 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<T_functor> _A_functor)
+ : adapts<T_functor>(_A_functor)
+ {}
+};
+
+template <class T_functor, class T_type1, class T_type2, class T_type3, class T_type4, class T_type5, class T_type6, class T_type7>
+typename retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::result_type
+retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::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 <class T_functor, class T_type1, class T_type2, class T_type3, class T_type4, class T_type5, class T_type6, class T_type7>
+struct visitor<retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7> >
+{
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>& _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 <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+inline retype_functor<slot<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >
+retype(const slot<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_functor)
+{ return retype_functor<slot<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >
+ (_A_functor); }
+
+
+/** 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 <class T_return>
+inline retype_functor<pointer_functor0<T_return> >
+retype(const pointer_functor0<T_return>& _A_functor)
+{ return retype_functor<pointer_functor0<T_return> >
+ (_A_functor); }
+
+/** 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 <class T_arg1, class T_return>
+inline retype_functor<pointer_functor1<T_arg1, T_return>, T_arg1 >
+retype(const pointer_functor1<T_arg1, T_return>& _A_functor)
+{ return retype_functor<pointer_functor1<T_arg1, T_return>, T_arg1 >
+ (_A_functor); }
+
+/** 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 <class T_arg1, class T_arg2, class T_return>
+inline retype_functor<pointer_functor2<T_arg1, T_arg2, T_return>, T_arg1, T_arg2 >
+retype(const pointer_functor2<T_arg1, T_arg2, T_return>& _A_functor)
+{ return retype_functor<pointer_functor2<T_arg1, T_arg2, T_return>, T_arg1, T_arg2 >
+ (_A_functor); }
+
+/** 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 <class T_arg1, class T_arg2, class T_arg3, class T_return>
+inline retype_functor<pointer_functor3<T_arg1, T_arg2, T_arg3, T_return>, T_arg1, T_arg2, T_arg3 >
+retype(const pointer_functor3<T_arg1, T_arg2, T_arg3, T_return>& _A_functor)
+{ return retype_functor<pointer_functor3<T_arg1, T_arg2, T_arg3, T_return>, T_arg1, T_arg2, T_arg3 >
+ (_A_functor); }
+
+/** 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return>
+inline retype_functor<pointer_functor4<T_arg1, T_arg2, T_arg3, T_arg4, T_return>, T_arg1, T_arg2, T_arg3, T_arg4 >
+retype(const pointer_functor4<T_arg1, T_arg2, T_arg3, T_arg4, T_return>& _A_functor)
+{ return retype_functor<pointer_functor4<T_arg1, T_arg2, T_arg3, T_arg4, T_return>, T_arg1, T_arg2, T_arg3, T_arg4 >
+ (_A_functor); }
+
+/** 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return>
+inline retype_functor<pointer_functor5<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >
+retype(const pointer_functor5<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return>& _A_functor)
+{ return retype_functor<pointer_functor5<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >
+ (_A_functor); }
+
+/** 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return>
+inline retype_functor<pointer_functor6<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >
+retype(const pointer_functor6<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return>& _A_functor)
+{ return retype_functor<pointer_functor6<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >
+ (_A_functor); }
+
+/** 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return>
+inline retype_functor<pointer_functor7<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >
+retype(const pointer_functor7<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return>& _A_functor)
+{ return retype_functor<pointer_functor7<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >
+ (_A_functor); }
+
+
+/** 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::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 <class T_return, class T_obj>
+inline retype_functor<mem_functor0<T_return, T_obj> >
+retype(const mem_functor0<T_return, T_obj>& _A_functor)
+{ return retype_functor<mem_functor0<T_return, T_obj> >
+ (_A_functor); }
+
+/** 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::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 <class T_return, class T_obj, class T_arg1>
+inline retype_functor<mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+retype(const mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
+{ return retype_functor<mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+ (_A_functor); }
+
+/** 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::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 <class T_return, class T_obj, class T_arg1, class T_arg2>
+inline retype_functor<mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
+retype(const mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_functor)
+{ return retype_functor<mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
+ (_A_functor); }
+
+/** 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::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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
+inline retype_functor<mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
+retype(const mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_functor)
+{ return retype_functor<mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
+ (_A_functor); }
+
+/** 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::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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+inline retype_functor<mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1, T_arg2, T_arg3, T_arg4 >
+retype(const mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_functor)
+{ return retype_functor<mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1, T_arg2, T_arg3, T_arg4 >
+ (_A_functor); }
+
+/** 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::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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+inline retype_functor<mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >
+retype(const mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_functor)
+{ return retype_functor<mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >
+ (_A_functor); }
+
+/** 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::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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+inline retype_functor<mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >
+retype(const mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_functor)
+{ return retype_functor<mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >
+ (_A_functor); }
+
+/** 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::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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+inline retype_functor<mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >
+retype(const mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_functor)
+{ return retype_functor<mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >
+ (_A_functor); }
+
+/** 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::const_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 <class T_return, class T_obj>
+inline retype_functor<const_mem_functor0<T_return, T_obj> >
+retype(const const_mem_functor0<T_return, T_obj>& _A_functor)
+{ return retype_functor<const_mem_functor0<T_return, T_obj> >
+ (_A_functor); }
+
+/** 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::const_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 <class T_return, class T_obj, class T_arg1>
+inline retype_functor<const_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+retype(const const_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
+{ return retype_functor<const_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+ (_A_functor); }
+
+/** 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::const_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 <class T_return, class T_obj, class T_arg1, class T_arg2>
+inline retype_functor<const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
+retype(const const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_functor)
+{ return retype_functor<const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
+ (_A_functor); }
+
+/** 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::const_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
+inline retype_functor<const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
+retype(const const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_functor)
+{ return retype_functor<const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
+ (_A_functor); }
+
+/** 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::const_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+inline retype_functor<const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1, T_arg2, T_arg3, T_arg4 >
+retype(const const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_functor)
+{ return retype_functor<const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1, T_arg2, T_arg3, T_arg4 >
+ (_A_functor); }
+
+/** 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::const_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+inline retype_functor<const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >
+retype(const const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_functor)
+{ return retype_functor<const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >
+ (_A_functor); }
+
+/** 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::const_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+inline retype_functor<const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >
+retype(const const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_functor)
+{ return retype_functor<const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >
+ (_A_functor); }
+
+/** 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::const_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+inline retype_functor<const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >
+retype(const const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_functor)
+{ return retype_functor<const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >
+ (_A_functor); }
+
+/** 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::volatile_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 <class T_return, class T_obj>
+inline retype_functor<volatile_mem_functor0<T_return, T_obj> >
+retype(const volatile_mem_functor0<T_return, T_obj>& _A_functor)
+{ return retype_functor<volatile_mem_functor0<T_return, T_obj> >
+ (_A_functor); }
+
+/** 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::volatile_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 <class T_return, class T_obj, class T_arg1>
+inline retype_functor<volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+retype(const volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
+{ return retype_functor<volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+ (_A_functor); }
+
+/** 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::volatile_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 <class T_return, class T_obj, class T_arg1, class T_arg2>
+inline retype_functor<volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
+retype(const volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_functor)
+{ return retype_functor<volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
+ (_A_functor); }
+
+/** 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::volatile_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
+inline retype_functor<volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
+retype(const volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_functor)
+{ return retype_functor<volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
+ (_A_functor); }
+
+/** 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::volatile_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+inline retype_functor<volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1, T_arg2, T_arg3, T_arg4 >
+retype(const volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_functor)
+{ return retype_functor<volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1, T_arg2, T_arg3, T_arg4 >
+ (_A_functor); }
+
+/** 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::volatile_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+inline retype_functor<volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >
+retype(const volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_functor)
+{ return retype_functor<volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >
+ (_A_functor); }
+
+/** 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::volatile_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+inline retype_functor<volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >
+retype(const volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_functor)
+{ return retype_functor<volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >
+ (_A_functor); }
+
+/** 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::volatile_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+inline retype_functor<volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >
+retype(const volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_functor)
+{ return retype_functor<volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >
+ (_A_functor); }
+
+/** 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::const_volatile_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 <class T_return, class T_obj>
+inline retype_functor<const_volatile_mem_functor0<T_return, T_obj> >
+retype(const const_volatile_mem_functor0<T_return, T_obj>& _A_functor)
+{ return retype_functor<const_volatile_mem_functor0<T_return, T_obj> >
+ (_A_functor); }
+
+/** 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::const_volatile_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 <class T_return, class T_obj, class T_arg1>
+inline retype_functor<const_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+retype(const const_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
+{ return retype_functor<const_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+ (_A_functor); }
+
+/** 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::const_volatile_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 <class T_return, class T_obj, class T_arg1, class T_arg2>
+inline retype_functor<const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
+retype(const const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_functor)
+{ return retype_functor<const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
+ (_A_functor); }
+
+/** 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::const_volatile_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
+inline retype_functor<const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
+retype(const const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_functor)
+{ return retype_functor<const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
+ (_A_functor); }
+
+/** 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::const_volatile_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+inline retype_functor<const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1, T_arg2, T_arg3, T_arg4 >
+retype(const const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_functor)
+{ return retype_functor<const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1, T_arg2, T_arg3, T_arg4 >
+ (_A_functor); }
+
+/** 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::const_volatile_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+inline retype_functor<const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >
+retype(const const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_functor)
+{ return retype_functor<const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >
+ (_A_functor); }
+
+/** 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::const_volatile_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+inline retype_functor<const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >
+retype(const const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_functor)
+{ return retype_functor<const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >
+ (_A_functor); }
+
+/** 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::const_volatile_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+inline retype_functor<const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >
+retype(const const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_functor)
+{ return retype_functor<const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >
+ (_A_functor); }
+
+/** 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::bound_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 <class T_return, class T_obj>
+inline retype_functor<bound_mem_functor0<T_return, T_obj> >
+retype(const bound_mem_functor0<T_return, T_obj>& _A_functor)
+{ return retype_functor<bound_mem_functor0<T_return, T_obj> >
+ (_A_functor); }
+
+/** 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::bound_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 <class T_return, class T_obj, class T_arg1>
+inline retype_functor<bound_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+retype(const bound_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
+{ return retype_functor<bound_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+ (_A_functor); }
+
+/** 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::bound_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 <class T_return, class T_obj, class T_arg1, class T_arg2>
+inline retype_functor<bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
+retype(const bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_functor)
+{ return retype_functor<bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
+ (_A_functor); }
+
+/** 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::bound_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
+inline retype_functor<bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
+retype(const bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_functor)
+{ return retype_functor<bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
+ (_A_functor); }
+
+/** 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::bound_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+inline retype_functor<bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1, T_arg2, T_arg3, T_arg4 >
+retype(const bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_functor)
+{ return retype_functor<bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1, T_arg2, T_arg3, T_arg4 >
+ (_A_functor); }
+
+/** 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::bound_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+inline retype_functor<bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >
+retype(const bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_functor)
+{ return retype_functor<bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >
+ (_A_functor); }
+
+/** 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::bound_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+inline retype_functor<bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >
+retype(const bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_functor)
+{ return retype_functor<bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >
+ (_A_functor); }
+
+/** 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::bound_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+inline retype_functor<bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >
+retype(const bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_functor)
+{ return retype_functor<bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >
+ (_A_functor); }
+
+/** 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::bound_const_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 <class T_return, class T_obj>
+inline retype_functor<bound_const_mem_functor0<T_return, T_obj> >
+retype(const bound_const_mem_functor0<T_return, T_obj>& _A_functor)
+{ return retype_functor<bound_const_mem_functor0<T_return, T_obj> >
+ (_A_functor); }
+
+/** 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::bound_const_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 <class T_return, class T_obj, class T_arg1>
+inline retype_functor<bound_const_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+retype(const bound_const_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
+{ return retype_functor<bound_const_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+ (_A_functor); }
+
+/** 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::bound_const_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 <class T_return, class T_obj, class T_arg1, class T_arg2>
+inline retype_functor<bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
+retype(const bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_functor)
+{ return retype_functor<bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
+ (_A_functor); }
+
+/** 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::bound_const_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
+inline retype_functor<bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
+retype(const bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_functor)
+{ return retype_functor<bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
+ (_A_functor); }
+
+/** 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::bound_const_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+inline retype_functor<bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1, T_arg2, T_arg3, T_arg4 >
+retype(const bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_functor)
+{ return retype_functor<bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1, T_arg2, T_arg3, T_arg4 >
+ (_A_functor); }
+
+/** 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::bound_const_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+inline retype_functor<bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >
+retype(const bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_functor)
+{ return retype_functor<bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >
+ (_A_functor); }
+
+/** 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::bound_const_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+inline retype_functor<bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >
+retype(const bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_functor)
+{ return retype_functor<bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >
+ (_A_functor); }
+
+/** 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::bound_const_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+inline retype_functor<bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >
+retype(const bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_functor)
+{ return retype_functor<bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >
+ (_A_functor); }
+
+/** 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::bound_volatile_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 <class T_return, class T_obj>
+inline retype_functor<bound_volatile_mem_functor0<T_return, T_obj> >
+retype(const bound_volatile_mem_functor0<T_return, T_obj>& _A_functor)
+{ return retype_functor<bound_volatile_mem_functor0<T_return, T_obj> >
+ (_A_functor); }
+
+/** 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::bound_volatile_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 <class T_return, class T_obj, class T_arg1>
+inline retype_functor<bound_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+retype(const bound_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
+{ return retype_functor<bound_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+ (_A_functor); }
+
+/** 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::bound_volatile_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 <class T_return, class T_obj, class T_arg1, class T_arg2>
+inline retype_functor<bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
+retype(const bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_functor)
+{ return retype_functor<bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
+ (_A_functor); }
+
+/** 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::bound_volatile_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
+inline retype_functor<bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
+retype(const bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_functor)
+{ return retype_functor<bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
+ (_A_functor); }
+
+/** 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::bound_volatile_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+inline retype_functor<bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1, T_arg2, T_arg3, T_arg4 >
+retype(const bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_functor)
+{ return retype_functor<bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1, T_arg2, T_arg3, T_arg4 >
+ (_A_functor); }
+
+/** 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::bound_volatile_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+inline retype_functor<bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >
+retype(const bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_functor)
+{ return retype_functor<bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >
+ (_A_functor); }
+
+/** 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::bound_volatile_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+inline retype_functor<bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >
+retype(const bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_functor)
+{ return retype_functor<bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >
+ (_A_functor); }
+
+/** 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::bound_volatile_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+inline retype_functor<bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >
+retype(const bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_functor)
+{ return retype_functor<bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >
+ (_A_functor); }
+
+/** 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::bound_const_volatile_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 <class T_return, class T_obj>
+inline retype_functor<bound_const_volatile_mem_functor0<T_return, T_obj> >
+retype(const bound_const_volatile_mem_functor0<T_return, T_obj>& _A_functor)
+{ return retype_functor<bound_const_volatile_mem_functor0<T_return, T_obj> >
+ (_A_functor); }
+
+/** 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::bound_const_volatile_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 <class T_return, class T_obj, class T_arg1>
+inline retype_functor<bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+retype(const bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
+{ return retype_functor<bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+ (_A_functor); }
+
+/** 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::bound_const_volatile_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 <class T_return, class T_obj, class T_arg1, class T_arg2>
+inline retype_functor<bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
+retype(const bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_functor)
+{ return retype_functor<bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
+ (_A_functor); }
+
+/** 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::bound_const_volatile_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
+inline retype_functor<bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
+retype(const bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_functor)
+{ return retype_functor<bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
+ (_A_functor); }
+
+/** 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::bound_const_volatile_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+inline retype_functor<bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1, T_arg2, T_arg3, T_arg4 >
+retype(const bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_functor)
+{ return retype_functor<bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1, T_arg2, T_arg3, T_arg4 >
+ (_A_functor); }
+
+/** 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::bound_const_volatile_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+inline retype_functor<bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >
+retype(const bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_functor)
+{ return retype_functor<bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 >
+ (_A_functor); }
+
+/** 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::bound_const_volatile_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+inline retype_functor<bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >
+retype(const bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_functor)
+{ return retype_functor<bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 >
+ (_A_functor); }
+
+/** 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::bound_const_volatile_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 <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+inline retype_functor<bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >
+retype(const bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_functor)
+{ return retype_functor<bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >
+ (_A_functor); }
+
+
+} /* namespace sigc */
+
+#ifdef SIGC_NIL_HAS_BEEN_PUSHED
+ #undef SIGC_NIL_HAS_BEEN_PUSHED
+ #pragma pop_macro("nil")
+#endif
+#endif /* _SIGC_ADAPTORS_RETYPE_H_ */
--- /dev/null
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+#ifndef _SIGC_ADAPTORS_RETYPE_RETURN_H_
+#define _SIGC_ADAPTORS_RETYPE_RETURN_H_
+#include <sigc++/adaptors/adaptor_trait.h>
+
+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 <class T_return, class T_functor>
+struct retype_return_functor : public adapts<T_functor>
+{
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef T_return type; };
+#endif
+ typedef T_return result_type;
+
+ T_return operator()();
+
+ template <class T_arg1>
+ inline T_return operator()(T_arg1 _A_a1)
+ { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>>
+ (_A_a1));
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1>
+ inline T_return sun_forte_workaround(T_arg1 _A_a1)
+ { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>>
+ (_A_a1));
+ }
+ #endif
+
+ template <class T_arg1, class T_arg2>
+ inline T_return operator()(T_arg1 _A_a1, T_arg2 _A_a2)
+ { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>>
+ (_A_a1, _A_a2));
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2>
+ inline T_return sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2)
+ { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>>
+ (_A_a1, _A_a2));
+ }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3>
+ inline T_return operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)
+ { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
+ (_A_a1, _A_a2, _A_a3));
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3>
+ inline T_return sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)
+ { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
+ (_A_a1, _A_a2, _A_a3));
+ }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ inline T_return operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
+ { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
+ (_A_a1, _A_a2, _A_a3, _A_a4));
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ inline T_return sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
+ { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
+ (_A_a1, _A_a2, _A_a3, _A_a4));
+ }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ inline T_return operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
+ { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5));
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ inline T_return sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
+ { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5));
+ }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ inline T_return operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
+ { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6));
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ inline T_return sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
+ { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6));
+ }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ inline T_return operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
+ { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7));
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ inline T_return sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
+ { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7));
+ }
+ #endif
+
+ 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(type_trait_take_t<T_functor> _A_functor)
+ : adapts<T_functor>(_A_functor)
+ {}
+};
+
+template <class T_return, class T_functor>
+T_return retype_return_functor<T_return, T_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<void>.
+ *
+ * @ingroup retype
+ */
+/* The void specialization is needed because of explicit cast to T_return.
+ */
+template <class T_functor>
+struct retype_return_functor<void, T_functor> : public adapts<T_functor>
+{
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+ template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
+ struct deduce_result_type
+ { typedef void type; };
+#endif
+ typedef void result_type;
+
+ void operator()();
+
+ template <class T_arg1>
+ inline void operator()(T_arg1 _A_a1)
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>>
+ (_A_a1);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1>
+ inline void sun_forte_workaround(T_arg1 _A_a1)
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>>
+ (_A_a1);
+ }
+ #endif
+
+ template <class T_arg1, class T_arg2>
+ inline void operator()(T_arg1 _A_a1, T_arg2 _A_a2)
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>>
+ (_A_a1, _A_a2);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2>
+ inline void sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2)
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>>
+ (_A_a1, _A_a2);
+ }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3>
+ inline void operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
+ (_A_a1, _A_a2, _A_a3);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3>
+ inline void sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
+ (_A_a1, _A_a2, _A_a3);
+ }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ inline void operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
+ (_A_a1, _A_a2, _A_a3, _A_a4);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+ inline void sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
+ (_A_a1, _A_a2, _A_a3, _A_a4);
+ }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ inline void operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+ inline void sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5);
+ }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ inline void operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+ inline void sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6);
+ }
+ #endif
+
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ inline void operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+ inline void sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
+ { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>
+ (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7);
+ }
+ #endif
+
+ retype_return_functor() {}
+ retype_return_functor(type_trait_take_t<T_functor> _A_functor)
+ : adapts<T_functor>(_A_functor)
+ {}
+};
+
+template <class T_functor>
+void retype_return_functor<void, T_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 <class T_return, class T_functor>
+struct visitor<retype_return_functor<T_return, T_functor> >
+{
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const retype_return_functor<T_return, T_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 <class T_return, class T_functor>
+inline retype_return_functor<T_return, T_functor>
+retype_return(const T_functor& _A_functor)
+ { return retype_return_functor<T_return, T_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 <class T_functor>
+inline retype_return_functor<void, T_functor>
+hide_return(const T_functor& _A_functor)
+ { return retype_return_functor<void, T_functor>(_A_functor); }
+
+} /* namespace sigc */
+#endif /* _SIGC_ADAPTORS_RETYPE_RETURN_H_ */
--- /dev/null
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+#ifndef _SIGC_ADAPTORS_TRACK_OBJ_H_
+#define _SIGC_ADAPTORS_TRACK_OBJ_H_
+#include <sigc++/adaptors/adaptor_trait.h>
+#include <sigc++/limit_reference.h>
+
+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 7 objects can be tracked. operator()() can have up to 7 arguments.
+ *
+ * @par Example:
+ * @code
+ * struct bar : public sigc::trackable {};
+ * sigc::signal<void> 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 <typename T_functor, typename T_obj1>
+class track_obj_functor1 : public adapts<T_functor>
+{
+public:
+ typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+ template <typename T_arg1=void, typename T_arg2=void, typename T_arg3=void, typename T_arg4=void, typename T_arg5=void, typename T_arg6=void, typename T_arg7=void>
+ struct deduce_result_type
+ { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>::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<T_functor>(_A_func), obj1_(_A_obj1) {}
+
+ /** Invokes the wrapped functor.
+ * @return The return value of the functor invocation.
+ */
+ result_type operator()()
+ { return this->functor_(); }
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <typename T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ operator()(T_arg1 _A_arg1)
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+ type_trait_pass_t<T_arg1>>
+ (_A_arg1);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <typename T_arg1>
+ typename deduce_result_type<T_arg1>::type
+ sun_forte_workaround(T_arg1 _A_arg1)
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+ type_trait_pass_t<T_arg1>>
+ (_A_arg1);
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <typename T_arg1, typename T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2)
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+ type_trait_pass_t<T_arg1>,
+ type_trait_pass_t<T_arg2>>
+ (_A_arg1, _A_arg2);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <typename T_arg1, typename T_arg2>
+ typename deduce_result_type<T_arg1, T_arg2>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2)
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+ type_trait_pass_t<T_arg1>,
+ type_trait_pass_t<T_arg2>>
+ (_A_arg1, _A_arg2);
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <typename T_arg1, typename T_arg2, typename T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+ type_trait_pass_t<T_arg1>,
+ type_trait_pass_t<T_arg2>,
+ type_trait_pass_t<T_arg3>>
+ (_A_arg1, _A_arg2, _A_arg3);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <typename T_arg1, typename T_arg2, typename T_arg3>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+ type_trait_pass_t<T_arg1>,
+ type_trait_pass_t<T_arg2>,
+ type_trait_pass_t<T_arg3>>
+ (_A_arg1, _A_arg2, _A_arg3);
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+ type_trait_pass_t<T_arg1>,
+ type_trait_pass_t<T_arg2>,
+ type_trait_pass_t<T_arg3>,
+ type_trait_pass_t<T_arg4>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+ type_trait_pass_t<T_arg1>,
+ type_trait_pass_t<T_arg2>,
+ type_trait_pass_t<T_arg3>,
+ type_trait_pass_t<T_arg4>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4);
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @param _A_arg5 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+ type_trait_pass_t<T_arg1>,
+ type_trait_pass_t<T_arg2>,
+ type_trait_pass_t<T_arg3>,
+ type_trait_pass_t<T_arg4>,
+ type_trait_pass_t<T_arg5>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+ type_trait_pass_t<T_arg1>,
+ type_trait_pass_t<T_arg2>,
+ type_trait_pass_t<T_arg3>,
+ type_trait_pass_t<T_arg4>,
+ type_trait_pass_t<T_arg5>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5);
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @param _A_arg5 Argument to be passed on to the functor.
+ * @param _A_arg6 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+ type_trait_pass_t<T_arg1>,
+ type_trait_pass_t<T_arg2>,
+ type_trait_pass_t<T_arg3>,
+ type_trait_pass_t<T_arg4>,
+ type_trait_pass_t<T_arg5>,
+ type_trait_pass_t<T_arg6>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+ type_trait_pass_t<T_arg1>,
+ type_trait_pass_t<T_arg2>,
+ type_trait_pass_t<T_arg3>,
+ type_trait_pass_t<T_arg4>,
+ type_trait_pass_t<T_arg5>,
+ type_trait_pass_t<T_arg6>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
+ }
+ #endif
+
+ /** Invokes the wrapped functor passing on the arguments.
+ * @param _A_arg1 Argument to be passed on to the functor.
+ * @param _A_arg2 Argument to be passed on to the functor.
+ * @param _A_arg3 Argument to be passed on to the functor.
+ * @param _A_arg4 Argument to be passed on to the functor.
+ * @param _A_arg5 Argument to be passed on to the functor.
+ * @param _A_arg6 Argument to be passed on to the functor.
+ * @param _A_arg7 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
+ operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6, T_arg7 _A_arg7)
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+ type_trait_pass_t<T_arg1>,
+ type_trait_pass_t<T_arg2>,
+ type_trait_pass_t<T_arg3>,
+ type_trait_pass_t<T_arg4>,
+ type_trait_pass_t<T_arg5>,
+ type_trait_pass_t<T_arg6>,
+ type_trait_pass_t<T_arg7>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6, _A_arg7);
+ }
+
+ #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
+ typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
+ sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6, T_arg7 _A_arg7)
+ {
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+ type_trait_pass_t<T_arg1>,
+ type_trait_pass_t<T_arg2>,
+ type_trait_pass_t<T_arg3>,
+ type_trait_pass_t<T_arg4>,
+ type_trait_pass_t<T_arg5>,
+ type_trait_pass_t<T_arg6>,
+ type_trait_pass_t<T_arg7>>
+ (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6, _A_arg7);
+ }
+ #endif
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+//protected:
+ // public, so that visit_each() can access it.
+ const_limit_reference<T_obj1> obj1_;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+}; // end class track_obj_functor1
+
+/** track_obj_functor2 wraps a functor and stores 2 references to trackable objects.
+ * Use the convenience function track_obj() to create an instance of track_obj_functor2.
+ *
+ * @tparam T_functor The type of functor to wrap.
+ * @tparam T_obj1 The type of a trackable object.
+ * @tparam T_obj2 The type of a trackable object.
+ *
+ * @newin{2,4}
+ *
+ * @ingroup track_obj
+ */
+template <typename T_functor, typename T_obj1, typename T_obj2>
+class track_obj_functor2 : public track_obj_functor1<T_functor, T_obj1>
+{
+public:
+ /** Constructs a track_obj_functor2 object that wraps the passed functor and
+ * stores references to the passed trackable objects.
+ * @param _A_func Functor.
+ * @param _A_obj1 Trackable object.
+ * @param _A_obj2 Trackable object.
+ */
+ track_obj_functor2(const T_functor& _A_func, const T_obj1& _A_obj1, const T_obj2& _A_obj2)
+ : track_obj_functor1<T_functor, T_obj1>(_A_func, _A_obj1), obj2_(_A_obj2) {}
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+//protected:
+ // public, so that visit_each() can access it.
+ const_limit_reference<T_obj2> obj2_;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+}; // end class track_obj_functor2
+
+/** track_obj_functor3 wraps a functor and stores 3 references to trackable objects.
+ * Use the convenience function track_obj() to create an instance of track_obj_functor3.
+ *
+ * @tparam T_functor The type of functor to wrap.
+ * @tparam T_obj1 The type of a trackable object.
+ * @tparam T_obj2 The type of a trackable object.
+ * @tparam T_obj3 The type of a trackable object.
+ *
+ * @newin{2,4}
+ *
+ * @ingroup track_obj
+ */
+template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3>
+class track_obj_functor3 : public track_obj_functor1<T_functor, T_obj1>
+{
+public:
+ /** Constructs a track_obj_functor3 object that wraps the passed functor and
+ * stores references to the passed trackable objects.
+ * @param _A_func Functor.
+ * @param _A_obj1 Trackable object.
+ * @param _A_obj2 Trackable object.
+ * @param _A_obj3 Trackable object.
+ */
+ track_obj_functor3(const T_functor& _A_func, const T_obj1& _A_obj1, const T_obj2& _A_obj2, const T_obj3& _A_obj3)
+ : track_obj_functor1<T_functor, T_obj1>(_A_func, _A_obj1), obj2_(_A_obj2), obj3_(_A_obj3) {}
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+//protected:
+ // public, so that visit_each() can access it.
+ const_limit_reference<T_obj2> obj2_;
+ const_limit_reference<T_obj3> obj3_;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+}; // end class track_obj_functor3
+
+/** track_obj_functor4 wraps a functor and stores 4 references to trackable objects.
+ * Use the convenience function track_obj() to create an instance of track_obj_functor4.
+ *
+ * @tparam T_functor The type of functor to wrap.
+ * @tparam T_obj1 The type of a trackable object.
+ * @tparam T_obj2 The type of a trackable object.
+ * @tparam T_obj3 The type of a trackable object.
+ * @tparam T_obj4 The type of a trackable object.
+ *
+ * @newin{2,4}
+ *
+ * @ingroup track_obj
+ */
+template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3, typename T_obj4>
+class track_obj_functor4 : public track_obj_functor1<T_functor, T_obj1>
+{
+public:
+ /** Constructs a track_obj_functor4 object that wraps the passed functor and
+ * stores references to the passed trackable objects.
+ * @param _A_func Functor.
+ * @param _A_obj1 Trackable object.
+ * @param _A_obj2 Trackable object.
+ * @param _A_obj3 Trackable object.
+ * @param _A_obj4 Trackable object.
+ */
+ track_obj_functor4(const T_functor& _A_func, const T_obj1& _A_obj1, const T_obj2& _A_obj2, const T_obj3& _A_obj3, const T_obj4& _A_obj4)
+ : track_obj_functor1<T_functor, T_obj1>(_A_func, _A_obj1), obj2_(_A_obj2), obj3_(_A_obj3), obj4_(_A_obj4) {}
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+//protected:
+ // public, so that visit_each() can access it.
+ const_limit_reference<T_obj2> obj2_;
+ const_limit_reference<T_obj3> obj3_;
+ const_limit_reference<T_obj4> obj4_;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+}; // end class track_obj_functor4
+
+/** track_obj_functor5 wraps a functor and stores 5 references to trackable objects.
+ * Use the convenience function track_obj() to create an instance of track_obj_functor5.
+ *
+ * @tparam T_functor The type of functor to wrap.
+ * @tparam T_obj1 The type of a trackable object.
+ * @tparam T_obj2 The type of a trackable object.
+ * @tparam T_obj3 The type of a trackable object.
+ * @tparam T_obj4 The type of a trackable object.
+ * @tparam T_obj5 The type of a trackable object.
+ *
+ * @newin{2,4}
+ *
+ * @ingroup track_obj
+ */
+template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3, typename T_obj4, typename T_obj5>
+class track_obj_functor5 : public track_obj_functor1<T_functor, T_obj1>
+{
+public:
+ /** Constructs a track_obj_functor5 object that wraps the passed functor and
+ * stores references to the passed trackable objects.
+ * @param _A_func Functor.
+ * @param _A_obj1 Trackable object.
+ * @param _A_obj2 Trackable object.
+ * @param _A_obj3 Trackable object.
+ * @param _A_obj4 Trackable object.
+ * @param _A_obj5 Trackable object.
+ */
+ track_obj_functor5(const T_functor& _A_func, const T_obj1& _A_obj1, const T_obj2& _A_obj2, const T_obj3& _A_obj3, const T_obj4& _A_obj4, const T_obj5& _A_obj5)
+ : track_obj_functor1<T_functor, T_obj1>(_A_func, _A_obj1), obj2_(_A_obj2), obj3_(_A_obj3), obj4_(_A_obj4), obj5_(_A_obj5) {}
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+//protected:
+ // public, so that visit_each() can access it.
+ const_limit_reference<T_obj2> obj2_;
+ const_limit_reference<T_obj3> obj3_;
+ const_limit_reference<T_obj4> obj4_;
+ const_limit_reference<T_obj5> obj5_;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+}; // end class track_obj_functor5
+
+/** track_obj_functor6 wraps a functor and stores 6 references to trackable objects.
+ * Use the convenience function track_obj() to create an instance of track_obj_functor6.
+ *
+ * @tparam T_functor The type of functor to wrap.
+ * @tparam T_obj1 The type of a trackable object.
+ * @tparam T_obj2 The type of a trackable object.
+ * @tparam T_obj3 The type of a trackable object.
+ * @tparam T_obj4 The type of a trackable object.
+ * @tparam T_obj5 The type of a trackable object.
+ * @tparam T_obj6 The type of a trackable object.
+ *
+ * @newin{2,4}
+ *
+ * @ingroup track_obj
+ */
+template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3, typename T_obj4, typename T_obj5, typename T_obj6>
+class track_obj_functor6 : public track_obj_functor1<T_functor, T_obj1>
+{
+public:
+ /** Constructs a track_obj_functor6 object that wraps the passed functor and
+ * stores references to the passed trackable objects.
+ * @param _A_func Functor.
+ * @param _A_obj1 Trackable object.
+ * @param _A_obj2 Trackable object.
+ * @param _A_obj3 Trackable object.
+ * @param _A_obj4 Trackable object.
+ * @param _A_obj5 Trackable object.
+ * @param _A_obj6 Trackable object.
+ */
+ track_obj_functor6(const T_functor& _A_func, const T_obj1& _A_obj1, const T_obj2& _A_obj2, const T_obj3& _A_obj3, const T_obj4& _A_obj4, const T_obj5& _A_obj5, const T_obj6& _A_obj6)
+ : track_obj_functor1<T_functor, T_obj1>(_A_func, _A_obj1), obj2_(_A_obj2), obj3_(_A_obj3), obj4_(_A_obj4), obj5_(_A_obj5), obj6_(_A_obj6) {}
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+//protected:
+ // public, so that visit_each() can access it.
+ const_limit_reference<T_obj2> obj2_;
+ const_limit_reference<T_obj3> obj3_;
+ const_limit_reference<T_obj4> obj4_;
+ const_limit_reference<T_obj5> obj5_;
+ const_limit_reference<T_obj6> obj6_;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+}; // end class track_obj_functor6
+
+/** track_obj_functor7 wraps a functor and stores 7 references to trackable objects.
+ * Use the convenience function track_obj() to create an instance of track_obj_functor7.
+ *
+ * @tparam T_functor The type of functor to wrap.
+ * @tparam T_obj1 The type of a trackable object.
+ * @tparam T_obj2 The type of a trackable object.
+ * @tparam T_obj3 The type of a trackable object.
+ * @tparam T_obj4 The type of a trackable object.
+ * @tparam T_obj5 The type of a trackable object.
+ * @tparam T_obj6 The type of a trackable object.
+ * @tparam T_obj7 The type of a trackable object.
+ *
+ * @newin{2,4}
+ *
+ * @ingroup track_obj
+ */
+template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3, typename T_obj4, typename T_obj5, typename T_obj6, typename T_obj7>
+class track_obj_functor7 : public track_obj_functor1<T_functor, T_obj1>
+{
+public:
+ /** Constructs a track_obj_functor7 object that wraps the passed functor and
+ * stores references to the passed trackable objects.
+ * @param _A_func Functor.
+ * @param _A_obj1 Trackable object.
+ * @param _A_obj2 Trackable object.
+ * @param _A_obj3 Trackable object.
+ * @param _A_obj4 Trackable object.
+ * @param _A_obj5 Trackable object.
+ * @param _A_obj6 Trackable object.
+ * @param _A_obj7 Trackable object.
+ */
+ track_obj_functor7(const T_functor& _A_func, const T_obj1& _A_obj1, const T_obj2& _A_obj2, const T_obj3& _A_obj3, const T_obj4& _A_obj4, const T_obj5& _A_obj5, const T_obj6& _A_obj6, const T_obj7& _A_obj7)
+ : track_obj_functor1<T_functor, T_obj1>(_A_func, _A_obj1), obj2_(_A_obj2), obj3_(_A_obj3), obj4_(_A_obj4), obj5_(_A_obj5), obj6_(_A_obj6), obj7_(_A_obj7) {}
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+//protected:
+ // public, so that visit_each() can access it.
+ const_limit_reference<T_obj2> obj2_;
+ const_limit_reference<T_obj3> obj3_;
+ const_limit_reference<T_obj4> obj4_;
+ const_limit_reference<T_obj5> obj5_;
+ const_limit_reference<T_obj6> obj6_;
+ const_limit_reference<T_obj7> obj7_;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+}; // end class track_obj_functor7
+
+
+#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_functor1 performs a functor
+ * on the functor and on the trackable object instances stored in the
+ * sigc::track_obj_functor1 object.
+ *
+ * @newin{2,4}
+ *
+ * @ingroup track_obj
+ */
+template <typename T_functor, typename T_obj1>
+struct visitor<track_obj_functor1<T_functor, T_obj1> >
+{
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const track_obj_functor1<T_functor, T_obj1>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.functor_);
+ sigc::visit_each(_A_action, _A_target.obj1_);
+ }
+};
+
+//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_functor2 performs a functor
+ * on the functor and on the trackable object instances stored in the
+ * sigc::track_obj_functor2 object.
+ *
+ * @newin{2,4}
+ *
+ * @ingroup track_obj
+ */
+template <typename T_functor, typename T_obj1, typename T_obj2>
+struct visitor<track_obj_functor2<T_functor, T_obj1, T_obj2> >
+{
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const track_obj_functor2<T_functor, T_obj1, T_obj2>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.functor_);
+ sigc::visit_each(_A_action, _A_target.obj1_);
+ sigc::visit_each(_A_action, _A_target.obj2_);
+ }
+};
+
+//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_functor3 performs a functor
+ * on the functor and on the trackable object instances stored in the
+ * sigc::track_obj_functor3 object.
+ *
+ * @newin{2,4}
+ *
+ * @ingroup track_obj
+ */
+template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3>
+struct visitor<track_obj_functor3<T_functor, T_obj1, T_obj2, T_obj3> >
+{
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const track_obj_functor3<T_functor, T_obj1, T_obj2, T_obj3>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.functor_);
+ sigc::visit_each(_A_action, _A_target.obj1_);
+ sigc::visit_each(_A_action, _A_target.obj2_);
+ sigc::visit_each(_A_action, _A_target.obj3_);
+ }
+};
+
+//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_functor4 performs a functor
+ * on the functor and on the trackable object instances stored in the
+ * sigc::track_obj_functor4 object.
+ *
+ * @newin{2,4}
+ *
+ * @ingroup track_obj
+ */
+template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3, typename T_obj4>
+struct visitor<track_obj_functor4<T_functor, T_obj1, T_obj2, T_obj3, T_obj4> >
+{
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const track_obj_functor4<T_functor, T_obj1, T_obj2, T_obj3, T_obj4>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.functor_);
+ sigc::visit_each(_A_action, _A_target.obj1_);
+ sigc::visit_each(_A_action, _A_target.obj2_);
+ sigc::visit_each(_A_action, _A_target.obj3_);
+ sigc::visit_each(_A_action, _A_target.obj4_);
+ }
+};
+
+//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_functor5 performs a functor
+ * on the functor and on the trackable object instances stored in the
+ * sigc::track_obj_functor5 object.
+ *
+ * @newin{2,4}
+ *
+ * @ingroup track_obj
+ */
+template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3, typename T_obj4, typename T_obj5>
+struct visitor<track_obj_functor5<T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5> >
+{
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const track_obj_functor5<T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.functor_);
+ sigc::visit_each(_A_action, _A_target.obj1_);
+ sigc::visit_each(_A_action, _A_target.obj2_);
+ sigc::visit_each(_A_action, _A_target.obj3_);
+ sigc::visit_each(_A_action, _A_target.obj4_);
+ sigc::visit_each(_A_action, _A_target.obj5_);
+ }
+};
+
+//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_functor6 performs a functor
+ * on the functor and on the trackable object instances stored in the
+ * sigc::track_obj_functor6 object.
+ *
+ * @newin{2,4}
+ *
+ * @ingroup track_obj
+ */
+template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3, typename T_obj4, typename T_obj5, typename T_obj6>
+struct visitor<track_obj_functor6<T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6> >
+{
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const track_obj_functor6<T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.functor_);
+ sigc::visit_each(_A_action, _A_target.obj1_);
+ sigc::visit_each(_A_action, _A_target.obj2_);
+ sigc::visit_each(_A_action, _A_target.obj3_);
+ sigc::visit_each(_A_action, _A_target.obj4_);
+ sigc::visit_each(_A_action, _A_target.obj5_);
+ sigc::visit_each(_A_action, _A_target.obj6_);
+ }
+};
+
+//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_functor7 performs a functor
+ * on the functor and on the trackable object instances stored in the
+ * sigc::track_obj_functor7 object.
+ *
+ * @newin{2,4}
+ *
+ * @ingroup track_obj
+ */
+template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3, typename T_obj4, typename T_obj5, typename T_obj6, typename T_obj7>
+struct visitor<track_obj_functor7<T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6, T_obj7> >
+{
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const track_obj_functor7<T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6, T_obj7>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.functor_);
+ sigc::visit_each(_A_action, _A_target.obj1_);
+ sigc::visit_each(_A_action, _A_target.obj2_);
+ sigc::visit_each(_A_action, _A_target.obj3_);
+ sigc::visit_each(_A_action, _A_target.obj4_);
+ sigc::visit_each(_A_action, _A_target.obj5_);
+ sigc::visit_each(_A_action, _A_target.obj6_);
+ sigc::visit_each(_A_action, _A_target.obj7_);
+ }
+};
+
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** Creates an adaptor of type sigc::track_obj_functor1 which wraps a functor.
+ * @param _A_func Functor that shall be wrapped.
+ * @param _A_obj1 Trackable object.
+ * @return Adaptor that executes _A_func() on invocation.
+ *
+ * @newin{2,4}
+ *
+ * @ingroup track_obj
+ */
+template <typename T_functor, typename T_obj1>
+inline track_obj_functor1<T_functor, T_obj1>
+track_obj(const T_functor& _A_func, const T_obj1& _A_obj1)
+{
+ return track_obj_functor1<T_functor, T_obj1>
+ (_A_func, _A_obj1);
+}
+
+/** Creates an adaptor of type sigc::track_obj_functor2 which wraps a functor.
+ * @param _A_func Functor that shall be wrapped.
+ * @param _A_obj1 Trackable object.
+ * @param _A_obj2 Trackable object.
+ * @return Adaptor that executes _A_func() on invocation.
+ *
+ * @newin{2,4}
+ *
+ * @ingroup track_obj
+ */
+template <typename T_functor, typename T_obj1, typename T_obj2>
+inline track_obj_functor2<T_functor, T_obj1, T_obj2>
+track_obj(const T_functor& _A_func, const T_obj1& _A_obj1, const T_obj2& _A_obj2)
+{
+ return track_obj_functor2<T_functor, T_obj1, T_obj2>
+ (_A_func, _A_obj1, _A_obj2);
+}
+
+/** Creates an adaptor of type sigc::track_obj_functor3 which wraps a functor.
+ * @param _A_func Functor that shall be wrapped.
+ * @param _A_obj1 Trackable object.
+ * @param _A_obj2 Trackable object.
+ * @param _A_obj3 Trackable object.
+ * @return Adaptor that executes _A_func() on invocation.
+ *
+ * @newin{2,4}
+ *
+ * @ingroup track_obj
+ */
+template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3>
+inline track_obj_functor3<T_functor, T_obj1, T_obj2, T_obj3>
+track_obj(const T_functor& _A_func, const T_obj1& _A_obj1, const T_obj2& _A_obj2, const T_obj3& _A_obj3)
+{
+ return track_obj_functor3<T_functor, T_obj1, T_obj2, T_obj3>
+ (_A_func, _A_obj1, _A_obj2, _A_obj3);
+}
+
+/** Creates an adaptor of type sigc::track_obj_functor4 which wraps a functor.
+ * @param _A_func Functor that shall be wrapped.
+ * @param _A_obj1 Trackable object.
+ * @param _A_obj2 Trackable object.
+ * @param _A_obj3 Trackable object.
+ * @param _A_obj4 Trackable object.
+ * @return Adaptor that executes _A_func() on invocation.
+ *
+ * @newin{2,4}
+ *
+ * @ingroup track_obj
+ */
+template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3, typename T_obj4>
+inline track_obj_functor4<T_functor, T_obj1, T_obj2, T_obj3, T_obj4>
+track_obj(const T_functor& _A_func, const T_obj1& _A_obj1, const T_obj2& _A_obj2, const T_obj3& _A_obj3, const T_obj4& _A_obj4)
+{
+ return track_obj_functor4<T_functor, T_obj1, T_obj2, T_obj3, T_obj4>
+ (_A_func, _A_obj1, _A_obj2, _A_obj3, _A_obj4);
+}
+
+/** Creates an adaptor of type sigc::track_obj_functor5 which wraps a functor.
+ * @param _A_func Functor that shall be wrapped.
+ * @param _A_obj1 Trackable object.
+ * @param _A_obj2 Trackable object.
+ * @param _A_obj3 Trackable object.
+ * @param _A_obj4 Trackable object.
+ * @param _A_obj5 Trackable object.
+ * @return Adaptor that executes _A_func() on invocation.
+ *
+ * @newin{2,4}
+ *
+ * @ingroup track_obj
+ */
+template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3, typename T_obj4, typename T_obj5>
+inline track_obj_functor5<T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5>
+track_obj(const T_functor& _A_func, const T_obj1& _A_obj1, const T_obj2& _A_obj2, const T_obj3& _A_obj3, const T_obj4& _A_obj4, const T_obj5& _A_obj5)
+{
+ return track_obj_functor5<T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5>
+ (_A_func, _A_obj1, _A_obj2, _A_obj3, _A_obj4, _A_obj5);
+}
+
+/** Creates an adaptor of type sigc::track_obj_functor6 which wraps a functor.
+ * @param _A_func Functor that shall be wrapped.
+ * @param _A_obj1 Trackable object.
+ * @param _A_obj2 Trackable object.
+ * @param _A_obj3 Trackable object.
+ * @param _A_obj4 Trackable object.
+ * @param _A_obj5 Trackable object.
+ * @param _A_obj6 Trackable object.
+ * @return Adaptor that executes _A_func() on invocation.
+ *
+ * @newin{2,4}
+ *
+ * @ingroup track_obj
+ */
+template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3, typename T_obj4, typename T_obj5, typename T_obj6>
+inline track_obj_functor6<T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6>
+track_obj(const T_functor& _A_func, const T_obj1& _A_obj1, const T_obj2& _A_obj2, const T_obj3& _A_obj3, const T_obj4& _A_obj4, const T_obj5& _A_obj5, const T_obj6& _A_obj6)
+{
+ return track_obj_functor6<T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6>
+ (_A_func, _A_obj1, _A_obj2, _A_obj3, _A_obj4, _A_obj5, _A_obj6);
+}
+
+/** Creates an adaptor of type sigc::track_obj_functor7 which wraps a functor.
+ * @param _A_func Functor that shall be wrapped.
+ * @param _A_obj1 Trackable object.
+ * @param _A_obj2 Trackable object.
+ * @param _A_obj3 Trackable object.
+ * @param _A_obj4 Trackable object.
+ * @param _A_obj5 Trackable object.
+ * @param _A_obj6 Trackable object.
+ * @param _A_obj7 Trackable object.
+ * @return Adaptor that executes _A_func() on invocation.
+ *
+ * @newin{2,4}
+ *
+ * @ingroup track_obj
+ */
+template <typename T_functor, typename T_obj1, typename T_obj2, typename T_obj3, typename T_obj4, typename T_obj5, typename T_obj6, typename T_obj7>
+inline track_obj_functor7<T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6, T_obj7>
+track_obj(const T_functor& _A_func, const T_obj1& _A_obj1, const T_obj2& _A_obj2, const T_obj3& _A_obj3, const T_obj4& _A_obj4, const T_obj5& _A_obj5, const T_obj6& _A_obj6, const T_obj7& _A_obj7)
+{
+ return track_obj_functor7<T_functor, T_obj1, T_obj2, T_obj3, T_obj4, T_obj5, T_obj6, T_obj7>
+ (_A_func, _A_obj1, _A_obj2, _A_obj3, _A_obj4, _A_obj5, _A_obj6, _A_obj7);
+}
+
+
+} /* namespace sigc */
+#endif /* _SIGC_ADAPTORS_TRACK_OBJ_H_ */
--- /dev/null
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+#ifndef _SIGC_FUNCTORS_FUNCTOR_TRAIT_H_
+#define _SIGC_FUNCTORS_FUNCTOR_TRAIT_H_
+#include <sigc++/type_traits.h>
+#include <type_traits>
+
+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
+ * <tt>typedef T_return result_type;</tt> 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 <typename T_functor>
+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 <typename X_functor>
+ 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<T_functor*>(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 <class T_functor,
+ bool I_derives_functor_base = std::is_base_of<functor_base,T_functor>::value,
+ bool I_can_use_decltype = can_deduce_result_type_with_decltype<T_functor>::value>
+struct functor_trait
+{
+ typedef void result_type;
+ typedef T_functor functor_type;
+};
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+template <class T_functor, bool I_can_use_decltype>
+struct functor_trait<T_functor, true, I_can_use_decltype>
+{
+ typedef typename T_functor::result_type result_type;
+ typedef T_functor functor_type;
+};
+
+template <typename T_functor>
+struct functor_trait<T_functor, false, true>
+{
+ typedef typename functor_trait<decltype(&T_functor::operator()), false, false>::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 <class T_functor> \
+struct functor_trait<T_functor, false, false> \
+{ \
+ 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<T_functor, false, false> \
+{ \
+ typedef T_return result_type; \
+ typedef T_functor functor_type; \
+}; \
+template <> \
+struct functor_trait<T_functor, false, true> \
+{ \
+ 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 <tt>decltype</tt>, 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.
+template <class T_return> class pointer_functor0;
+template <class T_return>
+struct functor_trait<T_return (*)(), false, false>
+{
+ typedef T_return result_type;
+ typedef pointer_functor0<T_return> functor_type;
+};
+
+template <class T_arg1, class T_return> class pointer_functor1;
+template <class T_arg1, class T_return>
+struct functor_trait<T_return (*)(T_arg1), false, false>
+{
+ typedef T_return result_type;
+ typedef pointer_functor1<T_arg1, T_return> functor_type;
+};
+
+template <class T_arg1, class T_arg2, class T_return> class pointer_functor2;
+template <class T_arg1, class T_arg2, class T_return>
+struct functor_trait<T_return (*)(T_arg1, T_arg2), false, false>
+{
+ typedef T_return result_type;
+ typedef pointer_functor2<T_arg1, T_arg2, T_return> functor_type;
+};
+
+template <class T_arg1, class T_arg2, class T_arg3, class T_return> class pointer_functor3;
+template <class T_arg1, class T_arg2, class T_arg3, class T_return>
+struct functor_trait<T_return (*)(T_arg1, T_arg2, T_arg3), false, false>
+{
+ typedef T_return result_type;
+ typedef pointer_functor3<T_arg1, T_arg2, T_arg3, T_return> functor_type;
+};
+
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return> class pointer_functor4;
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return>
+struct functor_trait<T_return (*)(T_arg1, T_arg2, T_arg3, T_arg4), false, false>
+{
+ typedef T_return result_type;
+ typedef pointer_functor4<T_arg1, T_arg2, T_arg3, T_arg4, T_return> functor_type;
+};
+
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return> class pointer_functor5;
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return>
+struct functor_trait<T_return (*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5), false, false>
+{
+ typedef T_return result_type;
+ typedef pointer_functor5<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return> functor_type;
+};
+
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return> class pointer_functor6;
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return>
+struct functor_trait<T_return (*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6), false, false>
+{
+ typedef T_return result_type;
+ typedef pointer_functor6<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return> functor_type;
+};
+
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return> class pointer_functor7;
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return>
+struct functor_trait<T_return (*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7), false, false>
+{
+ typedef T_return result_type;
+ typedef pointer_functor7<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return> functor_type;
+};
+
+
+template <class T_return, class T_obj> class mem_functor0;
+template <class T_return, class T_obj> class const_mem_functor0;
+template <class T_return, class T_obj>
+struct functor_trait<T_return (T_obj::*)(), false, false>
+{
+ typedef T_return result_type;
+ typedef mem_functor0<T_return, T_obj> functor_type;
+};
+template <class T_return, class T_obj>
+struct functor_trait<T_return (T_obj::*)() const, false, false>
+{
+ typedef T_return result_type;
+ typedef const_mem_functor0<T_return, T_obj> functor_type;
+};
+
+template <class T_return, class T_obj, class T_arg1> class mem_functor1;
+template <class T_return, class T_obj, class T_arg1> class const_mem_functor1;
+template <class T_arg1, class T_return, class T_obj>
+struct functor_trait<T_return (T_obj::*)(T_arg1), false, false>
+{
+ typedef T_return result_type;
+ typedef mem_functor1<T_return, T_obj, T_arg1> functor_type;
+};
+template <class T_arg1, class T_return, class T_obj>
+struct functor_trait<T_return (T_obj::*)(T_arg1) const, false, false>
+{
+ typedef T_return result_type;
+ typedef const_mem_functor1<T_return, T_obj, T_arg1> functor_type;
+};
+
+template <class T_return, class T_obj, class T_arg1, class T_arg2> class mem_functor2;
+template <class T_return, class T_obj, class T_arg1, class T_arg2> class const_mem_functor2;
+template <class T_arg1, class T_arg2, class T_return, class T_obj>
+struct functor_trait<T_return (T_obj::*)(T_arg1, T_arg2), false, false>
+{
+ typedef T_return result_type;
+ typedef mem_functor2<T_return, T_obj, T_arg1, T_arg2> functor_type;
+};
+template <class T_arg1, class T_arg2, class T_return, class T_obj>
+struct functor_trait<T_return (T_obj::*)(T_arg1, T_arg2) const, false, false>
+{
+ typedef T_return result_type;
+ typedef const_mem_functor2<T_return, T_obj, T_arg1, T_arg2> functor_type;
+};
+
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3> class mem_functor3;
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3> class const_mem_functor3;
+template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
+struct functor_trait<T_return (T_obj::*)(T_arg1, T_arg2, T_arg3), false, false>
+{
+ typedef T_return result_type;
+ typedef mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3> functor_type;
+};
+template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
+struct functor_trait<T_return (T_obj::*)(T_arg1, T_arg2, T_arg3) const, false, false>
+{
+ typedef T_return result_type;
+ typedef const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3> functor_type;
+};
+
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4> class mem_functor4;
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4> class const_mem_functor4;
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
+struct functor_trait<T_return (T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4), false, false>
+{
+ typedef T_return result_type;
+ typedef mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> functor_type;
+};
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
+struct functor_trait<T_return (T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4) const, false, false>
+{
+ typedef T_return result_type;
+ typedef const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> functor_type;
+};
+
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> class mem_functor5;
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> class const_mem_functor5;
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
+struct functor_trait<T_return (T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5), false, false>
+{
+ typedef T_return result_type;
+ typedef mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> functor_type;
+};
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
+struct functor_trait<T_return (T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const, false, false>
+{
+ typedef T_return result_type;
+ typedef const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> functor_type;
+};
+
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> class mem_functor6;
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> class const_mem_functor6;
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj>
+struct functor_trait<T_return (T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6), false, false>
+{
+ typedef T_return result_type;
+ typedef mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> functor_type;
+};
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj>
+struct functor_trait<T_return (T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const, false, false>
+{
+ typedef T_return result_type;
+ typedef const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> functor_type;
+};
+
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> class mem_functor7;
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> class const_mem_functor7;
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj>
+struct functor_trait<T_return (T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7), false, false>
+{
+ typedef T_return result_type;
+ typedef mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> functor_type;
+};
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj>
+struct functor_trait<T_return (T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const, false, false>
+{
+ typedef T_return result_type;
+ typedef const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> functor_type;
+};
+
+
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+} /* namespace sigc */
+#endif /* _SIGC_FUNCTORS_FUNCTOR_TRAIT_H_ */
--- /dev/null
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+
+
+// 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.
+#ifndef _SIGC_FUNCTORS_MEM_FUN_H_
+#define _SIGC_FUNCTORS_MEM_FUN_H_
+#include <sigc++/type_traits.h>
+#include <sigc++/functors/functor_trait.h>
+#include <sigc++/limit_reference.h>
+
+namespace sigc {
+
+/** @defgroup mem_fun mem_fun()
+ * mem_fun() Creates a functor from a pointer to a method.
+ *
+ * Optionally, a reference or pointer 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 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.
+ *
+ * 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<void, int> 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<void, int> 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<void, int> sl = sigc::mem_fun1<int>(my_foo, &foo::bar);
+ * @endcode
+ *
+ * @ingroup sigcfunctors
+ */
+
+/** mem_functor0 wraps methods with 0 argument(s).
+ * Use the convenience function mem_fun() to create an instance of mem_functor0.
+ *
+ * The following template arguments are used:
+ * - @e T_return The return type of operator()().
+ * - @e T_obj The object type.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj>
+class mem_functor0 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)() ;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ mem_functor0() : func_ptr_(nullptr) {}
+
+ /** Constructs a mem_functor0 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit mem_functor0(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj* _A_obj) const
+ { return (_A_obj->*(this->func_ptr_))(); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj& _A_obj) const
+ { return (_A_obj.*func_ptr_)(); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** mem_functor1 wraps methods with 1 argument(s).
+ * Use the convenience function mem_fun() to create an instance of mem_functor1.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 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 T_return, class T_obj, class T_arg1>
+class mem_functor1 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)(T_arg1) ;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ mem_functor1() : func_ptr_(nullptr) {}
+
+ /** Constructs a mem_functor1 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit mem_functor1(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1) const
+ { return (_A_obj->*(this->func_ptr_))(_A_a1); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1) const
+ { return (_A_obj.*func_ptr_)(_A_a1); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** mem_functor2 wraps methods with 2 argument(s).
+ * Use the convenience function mem_fun() to create an instance of mem_functor2.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 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 T_return, class T_obj, class T_arg1, class T_arg2>
+class mem_functor2 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)(T_arg1, T_arg2) ;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ mem_functor2() : func_ptr_(nullptr) {}
+
+ /** Constructs a mem_functor2 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit mem_functor2(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
+ { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
+ { return (_A_obj.*func_ptr_)(_A_a1, _A_a2); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** mem_functor3 wraps methods with 3 argument(s).
+ * Use the convenience function mem_fun() to create an instance of mem_functor3.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
+class mem_functor3 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3) ;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ mem_functor3() : func_ptr_(nullptr) {}
+
+ /** Constructs a mem_functor3 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit mem_functor3(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
+ { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
+ { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** mem_functor4 wraps methods with 4 argument(s).
+ * Use the convenience function mem_fun() to create an instance of mem_functor4.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+class mem_functor4 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4) ;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ mem_functor4() : func_ptr_(nullptr) {}
+
+ /** Constructs a mem_functor4 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit mem_functor4(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
+ { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
+ { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** mem_functor5 wraps methods with 5 argument(s).
+ * Use the convenience function mem_fun() to create an instance of mem_functor5.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 Argument type used in the definition of operator()().
+ * - @e T_arg5 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+class mem_functor5 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) ;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ mem_functor5() : func_ptr_(nullptr) {}
+
+ /** Constructs a mem_functor5 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit mem_functor5(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
+ { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
+ { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** mem_functor6 wraps methods with 6 argument(s).
+ * Use the convenience function mem_fun() to create an instance of mem_functor6.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 Argument type used in the definition of operator()().
+ * - @e T_arg5 Argument type used in the definition of operator()().
+ * - @e T_arg6 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+class mem_functor6 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) ;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ mem_functor6() : func_ptr_(nullptr) {}
+
+ /** Constructs a mem_functor6 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit mem_functor6(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @param _A_a6 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
+ { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @param _A_a6 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
+ { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** mem_functor7 wraps methods with 7 argument(s).
+ * Use the convenience function mem_fun() to create an instance of mem_functor7.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 Argument type used in the definition of operator()().
+ * - @e T_arg5 Argument type used in the definition of operator()().
+ * - @e T_arg6 Argument type used in the definition of operator()().
+ * - @e T_arg7 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+class mem_functor7 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) ;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ mem_functor7() : func_ptr_(nullptr) {}
+
+ /** Constructs a mem_functor7 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit mem_functor7(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @param _A_a6 Argument to be passed on to the method.
+ * @param _A_a7 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
+ { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @param _A_a6 Argument to be passed on to the method.
+ * @param _A_a7 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
+ { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** const_mem_functor0 wraps const methods with 0 argument(s).
+ * Use the convenience function mem_fun() to create an instance of const_mem_functor0.
+ *
+ * The following template arguments are used:
+ * - @e T_return The return type of operator()().
+ * - @e T_obj The object type.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj>
+class const_mem_functor0 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)() const;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ const_mem_functor0() : func_ptr_(nullptr) {}
+
+ /** Constructs a const_mem_functor0 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit const_mem_functor0(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj* _A_obj) const
+ { return (_A_obj->*(this->func_ptr_))(); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj& _A_obj) const
+ { return (_A_obj.*func_ptr_)(); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** const_mem_functor1 wraps const methods with 1 argument(s).
+ * Use the convenience function mem_fun() to create an instance of const_mem_functor1.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 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 T_return, class T_obj, class T_arg1>
+class const_mem_functor1 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)(T_arg1) const;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ const_mem_functor1() : func_ptr_(nullptr) {}
+
+ /** Constructs a const_mem_functor1 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit const_mem_functor1(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1) const
+ { return (_A_obj->*(this->func_ptr_))(_A_a1); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1) const
+ { return (_A_obj.*func_ptr_)(_A_a1); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** const_mem_functor2 wraps const methods with 2 argument(s).
+ * Use the convenience function mem_fun() to create an instance of const_mem_functor2.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 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 T_return, class T_obj, class T_arg1, class T_arg2>
+class const_mem_functor2 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)(T_arg1, T_arg2) const;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ const_mem_functor2() : func_ptr_(nullptr) {}
+
+ /** Constructs a const_mem_functor2 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit const_mem_functor2(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
+ { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
+ { return (_A_obj.*func_ptr_)(_A_a1, _A_a2); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** const_mem_functor3 wraps const methods with 3 argument(s).
+ * Use the convenience function mem_fun() to create an instance of const_mem_functor3.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
+class const_mem_functor3 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3) const;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ const_mem_functor3() : func_ptr_(nullptr) {}
+
+ /** Constructs a const_mem_functor3 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit const_mem_functor3(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
+ { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
+ { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** const_mem_functor4 wraps const methods with 4 argument(s).
+ * Use the convenience function mem_fun() to create an instance of const_mem_functor4.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+class const_mem_functor4 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4) const;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ const_mem_functor4() : func_ptr_(nullptr) {}
+
+ /** Constructs a const_mem_functor4 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit const_mem_functor4(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
+ { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
+ { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** const_mem_functor5 wraps const methods with 5 argument(s).
+ * Use the convenience function mem_fun() to create an instance of const_mem_functor5.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 Argument type used in the definition of operator()().
+ * - @e T_arg5 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+class const_mem_functor5 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ const_mem_functor5() : func_ptr_(nullptr) {}
+
+ /** Constructs a const_mem_functor5 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit const_mem_functor5(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
+ { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
+ { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** const_mem_functor6 wraps const methods with 6 argument(s).
+ * Use the convenience function mem_fun() to create an instance of const_mem_functor6.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 Argument type used in the definition of operator()().
+ * - @e T_arg5 Argument type used in the definition of operator()().
+ * - @e T_arg6 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+class const_mem_functor6 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ const_mem_functor6() : func_ptr_(nullptr) {}
+
+ /** Constructs a const_mem_functor6 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit const_mem_functor6(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @param _A_a6 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
+ { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @param _A_a6 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
+ { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** const_mem_functor7 wraps const methods with 7 argument(s).
+ * Use the convenience function mem_fun() to create an instance of const_mem_functor7.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 Argument type used in the definition of operator()().
+ * - @e T_arg5 Argument type used in the definition of operator()().
+ * - @e T_arg6 Argument type used in the definition of operator()().
+ * - @e T_arg7 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+class const_mem_functor7 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ const_mem_functor7() : func_ptr_(nullptr) {}
+
+ /** Constructs a const_mem_functor7 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit const_mem_functor7(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @param _A_a6 Argument to be passed on to the method.
+ * @param _A_a7 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
+ { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @param _A_a6 Argument to be passed on to the method.
+ * @param _A_a7 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
+ { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** volatile_mem_functor0 wraps volatile methods with 0 argument(s).
+ * Use the convenience function mem_fun() to create an instance of volatile_mem_functor0.
+ *
+ * The following template arguments are used:
+ * - @e T_return The return type of operator()().
+ * - @e T_obj The object type.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj>
+class volatile_mem_functor0 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)() volatile;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ volatile_mem_functor0() : func_ptr_(nullptr) {}
+
+ /** Constructs a volatile_mem_functor0 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit volatile_mem_functor0(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj* _A_obj) const
+ { return (_A_obj->*(this->func_ptr_))(); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj& _A_obj) const
+ { return (_A_obj.*func_ptr_)(); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** volatile_mem_functor1 wraps volatile methods with 1 argument(s).
+ * Use the convenience function mem_fun() to create an instance of volatile_mem_functor1.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 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 T_return, class T_obj, class T_arg1>
+class volatile_mem_functor1 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)(T_arg1) volatile;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ volatile_mem_functor1() : func_ptr_(nullptr) {}
+
+ /** Constructs a volatile_mem_functor1 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit volatile_mem_functor1(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1) const
+ { return (_A_obj->*(this->func_ptr_))(_A_a1); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1) const
+ { return (_A_obj.*func_ptr_)(_A_a1); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** volatile_mem_functor2 wraps volatile methods with 2 argument(s).
+ * Use the convenience function mem_fun() to create an instance of volatile_mem_functor2.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 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 T_return, class T_obj, class T_arg1, class T_arg2>
+class volatile_mem_functor2 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)(T_arg1, T_arg2) volatile;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ volatile_mem_functor2() : func_ptr_(nullptr) {}
+
+ /** Constructs a volatile_mem_functor2 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit volatile_mem_functor2(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
+ { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
+ { return (_A_obj.*func_ptr_)(_A_a1, _A_a2); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** volatile_mem_functor3 wraps volatile methods with 3 argument(s).
+ * Use the convenience function mem_fun() to create an instance of volatile_mem_functor3.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
+class volatile_mem_functor3 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3) volatile;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ volatile_mem_functor3() : func_ptr_(nullptr) {}
+
+ /** Constructs a volatile_mem_functor3 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit volatile_mem_functor3(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
+ { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
+ { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** volatile_mem_functor4 wraps volatile methods with 4 argument(s).
+ * Use the convenience function mem_fun() to create an instance of volatile_mem_functor4.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+class volatile_mem_functor4 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4) volatile;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ volatile_mem_functor4() : func_ptr_(nullptr) {}
+
+ /** Constructs a volatile_mem_functor4 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit volatile_mem_functor4(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
+ { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
+ { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** volatile_mem_functor5 wraps volatile methods with 5 argument(s).
+ * Use the convenience function mem_fun() to create an instance of volatile_mem_functor5.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 Argument type used in the definition of operator()().
+ * - @e T_arg5 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+class volatile_mem_functor5 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ volatile_mem_functor5() : func_ptr_(nullptr) {}
+
+ /** Constructs a volatile_mem_functor5 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit volatile_mem_functor5(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
+ { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
+ { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** volatile_mem_functor6 wraps volatile methods with 6 argument(s).
+ * Use the convenience function mem_fun() to create an instance of volatile_mem_functor6.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 Argument type used in the definition of operator()().
+ * - @e T_arg5 Argument type used in the definition of operator()().
+ * - @e T_arg6 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+class volatile_mem_functor6 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ volatile_mem_functor6() : func_ptr_(nullptr) {}
+
+ /** Constructs a volatile_mem_functor6 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit volatile_mem_functor6(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @param _A_a6 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
+ { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @param _A_a6 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
+ { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** volatile_mem_functor7 wraps volatile methods with 7 argument(s).
+ * Use the convenience function mem_fun() to create an instance of volatile_mem_functor7.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 Argument type used in the definition of operator()().
+ * - @e T_arg5 Argument type used in the definition of operator()().
+ * - @e T_arg6 Argument type used in the definition of operator()().
+ * - @e T_arg7 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+class volatile_mem_functor7 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ volatile_mem_functor7() : func_ptr_(nullptr) {}
+
+ /** Constructs a volatile_mem_functor7 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit volatile_mem_functor7(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @param _A_a6 Argument to be passed on to the method.
+ * @param _A_a7 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
+ { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @param _A_a6 Argument to be passed on to the method.
+ * @param _A_a7 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
+ { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** const_volatile_mem_functor0 wraps const volatile methods with 0 argument(s).
+ * Use the convenience function mem_fun() to create an instance of const_volatile_mem_functor0.
+ *
+ * The following template arguments are used:
+ * - @e T_return The return type of operator()().
+ * - @e T_obj The object type.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj>
+class const_volatile_mem_functor0 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)() const volatile;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ const_volatile_mem_functor0() : func_ptr_(nullptr) {}
+
+ /** Constructs a const_volatile_mem_functor0 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit const_volatile_mem_functor0(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj* _A_obj) const
+ { return (_A_obj->*(this->func_ptr_))(); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj& _A_obj) const
+ { return (_A_obj.*func_ptr_)(); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** const_volatile_mem_functor1 wraps const volatile methods with 1 argument(s).
+ * Use the convenience function mem_fun() to create an instance of const_volatile_mem_functor1.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 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 T_return, class T_obj, class T_arg1>
+class const_volatile_mem_functor1 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)(T_arg1) const volatile;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ const_volatile_mem_functor1() : func_ptr_(nullptr) {}
+
+ /** Constructs a const_volatile_mem_functor1 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit const_volatile_mem_functor1(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1) const
+ { return (_A_obj->*(this->func_ptr_))(_A_a1); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1) const
+ { return (_A_obj.*func_ptr_)(_A_a1); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** const_volatile_mem_functor2 wraps const volatile methods with 2 argument(s).
+ * Use the convenience function mem_fun() to create an instance of const_volatile_mem_functor2.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 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 T_return, class T_obj, class T_arg1, class T_arg2>
+class const_volatile_mem_functor2 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)(T_arg1, T_arg2) const volatile;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ const_volatile_mem_functor2() : func_ptr_(nullptr) {}
+
+ /** Constructs a const_volatile_mem_functor2 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit const_volatile_mem_functor2(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
+ { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
+ { return (_A_obj.*func_ptr_)(_A_a1, _A_a2); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** const_volatile_mem_functor3 wraps const volatile methods with 3 argument(s).
+ * Use the convenience function mem_fun() to create an instance of const_volatile_mem_functor3.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
+class const_volatile_mem_functor3 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3) const volatile;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ const_volatile_mem_functor3() : func_ptr_(nullptr) {}
+
+ /** Constructs a const_volatile_mem_functor3 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit const_volatile_mem_functor3(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
+ { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
+ { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** const_volatile_mem_functor4 wraps const volatile methods with 4 argument(s).
+ * Use the convenience function mem_fun() to create an instance of const_volatile_mem_functor4.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+class const_volatile_mem_functor4 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ const_volatile_mem_functor4() : func_ptr_(nullptr) {}
+
+ /** Constructs a const_volatile_mem_functor4 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit const_volatile_mem_functor4(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
+ { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
+ { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** const_volatile_mem_functor5 wraps const volatile methods with 5 argument(s).
+ * Use the convenience function mem_fun() to create an instance of const_volatile_mem_functor5.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 Argument type used in the definition of operator()().
+ * - @e T_arg5 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+class const_volatile_mem_functor5 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ const_volatile_mem_functor5() : func_ptr_(nullptr) {}
+
+ /** Constructs a const_volatile_mem_functor5 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit const_volatile_mem_functor5(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
+ { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
+ { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** const_volatile_mem_functor6 wraps const volatile methods with 6 argument(s).
+ * Use the convenience function mem_fun() to create an instance of const_volatile_mem_functor6.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 Argument type used in the definition of operator()().
+ * - @e T_arg5 Argument type used in the definition of operator()().
+ * - @e T_arg6 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+class const_volatile_mem_functor6 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ const_volatile_mem_functor6() : func_ptr_(nullptr) {}
+
+ /** Constructs a const_volatile_mem_functor6 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit const_volatile_mem_functor6(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @param _A_a6 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
+ { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @param _A_a6 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
+ { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
+
+protected:
+ function_type func_ptr_;
+};
+
+/** const_volatile_mem_functor7 wraps const volatile methods with 7 argument(s).
+ * Use the convenience function mem_fun() to create an instance of const_volatile_mem_functor7.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 Argument type used in the definition of operator()().
+ * - @e T_arg5 Argument type used in the definition of operator()().
+ * - @e T_arg6 Argument type used in the definition of operator()().
+ * - @e T_arg7 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+class const_volatile_mem_functor7 : public functor_base
+{
+public:
+ typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile;
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ const_volatile_mem_functor7() : func_ptr_(nullptr) {}
+
+ /** Constructs a const_volatile_mem_functor7 object that wraps the passed method.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ explicit const_volatile_mem_functor7(function_type _A_func) : func_ptr_(_A_func) {}
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Execute the wrapped method operating on the passed instance.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @param _A_a6 Argument to be passed on to the method.
+ * @param _A_a7 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
+ { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+ /** Execute the wrapped method operating on the passed instance.
+ * @param _A_obj Reference to instance the method should operate on.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @param _A_a6 Argument to be passed on to the method.
+ * @param _A_a7 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
+ { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
+
+protected:
+ function_type func_ptr_;
+};
+
+
+/** bound_mem_functor0 encapsulates a method with 0 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_mem_functor0.
+ *
+ * The following template arguments are used:
+ * - @e T_return The return type of operator()().
+ * - @e T_obj The object type.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj>
+class bound_mem_functor0
+ : public mem_functor0<T_return, T_obj>
+{
+ typedef mem_functor0<T_return, T_obj> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_mem_functor0 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_mem_functor0( T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_mem_functor0 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_mem_functor0( T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()() const
+ { return (obj_.invoke().*(this->func_ptr_))(); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ limit_reference<T_obj> 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_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj>
+struct visitor<bound_mem_functor0<T_return, T_obj> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_mem_functor0<T_return, T_obj>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_mem_functor1 encapsulates a method with 1 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_mem_functor1.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 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 T_return, class T_obj, class T_arg1>
+class bound_mem_functor1
+ : public mem_functor1<T_return, T_obj, T_arg1>
+{
+ typedef mem_functor1<T_return, T_obj, T_arg1> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_mem_functor1 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_mem_functor1( T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_mem_functor1 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_mem_functor1( T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1) const
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ limit_reference<T_obj> 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_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj, class T_arg1>
+struct visitor<bound_mem_functor1<T_return, T_obj, T_arg1> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_mem_functor1<T_return, T_obj, T_arg1>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_mem_functor2 encapsulates a method with 2 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_mem_functor2.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 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 T_return, class T_obj, class T_arg1, class T_arg2>
+class bound_mem_functor2
+ : public mem_functor2<T_return, T_obj, T_arg1, T_arg2>
+{
+ typedef mem_functor2<T_return, T_obj, T_arg1, T_arg2> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_mem_functor2 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_mem_functor2( T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_mem_functor2 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_mem_functor2( T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ limit_reference<T_obj> 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_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj, class T_arg1, class T_arg2>
+struct visitor<bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_mem_functor3 encapsulates a method with 3 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_mem_functor3.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
+class bound_mem_functor3
+ : public mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
+{
+ typedef mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_mem_functor3 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_mem_functor3( T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_mem_functor3 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_mem_functor3( T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ limit_reference<T_obj> 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_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
+struct visitor<bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_mem_functor4 encapsulates a method with 4 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_mem_functor4.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+class bound_mem_functor4
+ : public mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
+{
+ typedef mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_mem_functor4 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_mem_functor4( T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_mem_functor4 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_mem_functor4( T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ limit_reference<T_obj> 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_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+struct visitor<bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_mem_functor5 encapsulates a method with 5 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_mem_functor5.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 Argument type used in the definition of operator()().
+ * - @e T_arg5 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+class bound_mem_functor5
+ : public mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+{
+ typedef mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_mem_functor5 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_mem_functor5( T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_mem_functor5 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_mem_functor5( T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ limit_reference<T_obj> 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_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+struct visitor<bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_mem_functor6 encapsulates a method with 6 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_mem_functor6.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 Argument type used in the definition of operator()().
+ * - @e T_arg5 Argument type used in the definition of operator()().
+ * - @e T_arg6 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+class bound_mem_functor6
+ : public mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+{
+ typedef mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_mem_functor6 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_mem_functor6( T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_mem_functor6 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_mem_functor6( T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @param _A_a6 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ limit_reference<T_obj> 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_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+struct visitor<bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_mem_functor7 encapsulates a method with 7 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_mem_functor7.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 Argument type used in the definition of operator()().
+ * - @e T_arg5 Argument type used in the definition of operator()().
+ * - @e T_arg6 Argument type used in the definition of operator()().
+ * - @e T_arg7 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+class bound_mem_functor7
+ : public mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+{
+ typedef mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_mem_functor7 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_mem_functor7( T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_mem_functor7 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_mem_functor7( T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @param _A_a6 Argument to be passed on to the method.
+ * @param _A_a7 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ limit_reference<T_obj> 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_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+struct visitor<bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_const_mem_functor0.
+ *
+ * The following template arguments are used:
+ * - @e T_return The return type of operator()().
+ * - @e T_obj The object type.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj>
+class bound_const_mem_functor0
+ : public const_mem_functor0<T_return, T_obj>
+{
+ typedef const_mem_functor0<T_return, T_obj> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_const_mem_functor0 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_const_mem_functor0(const T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_const_mem_functor0 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_const_mem_functor0(const T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()() const
+ { return (obj_.invoke().*(this->func_ptr_))(); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_limit_reference<T_obj> 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_const_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_const_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj>
+struct visitor<bound_const_mem_functor0<T_return, T_obj> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_const_mem_functor0<T_return, T_obj>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_const_mem_functor1.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 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 T_return, class T_obj, class T_arg1>
+class bound_const_mem_functor1
+ : public const_mem_functor1<T_return, T_obj, T_arg1>
+{
+ typedef const_mem_functor1<T_return, T_obj, T_arg1> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_const_mem_functor1 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_const_mem_functor1(const T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_const_mem_functor1 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_const_mem_functor1(const T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1) const
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_limit_reference<T_obj> 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_const_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_const_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj, class T_arg1>
+struct visitor<bound_const_mem_functor1<T_return, T_obj, T_arg1> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_const_mem_functor1<T_return, T_obj, T_arg1>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_const_mem_functor2.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 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 T_return, class T_obj, class T_arg1, class T_arg2>
+class bound_const_mem_functor2
+ : public const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
+{
+ typedef const_mem_functor2<T_return, T_obj, T_arg1, T_arg2> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_const_mem_functor2 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_const_mem_functor2(const T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_const_mem_functor2 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_const_mem_functor2(const T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_limit_reference<T_obj> 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_const_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_const_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj, class T_arg1, class T_arg2>
+struct visitor<bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_const_mem_functor3.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
+class bound_const_mem_functor3
+ : public const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
+{
+ typedef const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_const_mem_functor3 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_const_mem_functor3(const T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_const_mem_functor3 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_const_mem_functor3(const T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_limit_reference<T_obj> 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_const_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_const_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
+struct visitor<bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_const_mem_functor4.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+class bound_const_mem_functor4
+ : public const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
+{
+ typedef const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_const_mem_functor4 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_const_mem_functor4(const T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_const_mem_functor4 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_const_mem_functor4(const T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_limit_reference<T_obj> 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_const_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_const_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+struct visitor<bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_const_mem_functor5.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 Argument type used in the definition of operator()().
+ * - @e T_arg5 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+class bound_const_mem_functor5
+ : public const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+{
+ typedef const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_const_mem_functor5 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_const_mem_functor5(const T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_const_mem_functor5 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_const_mem_functor5(const T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_limit_reference<T_obj> 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_const_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_const_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+struct visitor<bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_const_mem_functor6.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 Argument type used in the definition of operator()().
+ * - @e T_arg5 Argument type used in the definition of operator()().
+ * - @e T_arg6 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+class bound_const_mem_functor6
+ : public const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+{
+ typedef const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_const_mem_functor6 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_const_mem_functor6(const T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_const_mem_functor6 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_const_mem_functor6(const T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @param _A_a6 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_limit_reference<T_obj> 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_const_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_const_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+struct visitor<bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_const_mem_functor7.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 Argument type used in the definition of operator()().
+ * - @e T_arg5 Argument type used in the definition of operator()().
+ * - @e T_arg6 Argument type used in the definition of operator()().
+ * - @e T_arg7 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+class bound_const_mem_functor7
+ : public const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+{
+ typedef const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_const_mem_functor7 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_const_mem_functor7(const T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_const_mem_functor7 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_const_mem_functor7(const T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @param _A_a6 Argument to be passed on to the method.
+ * @param _A_a7 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_limit_reference<T_obj> 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_const_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_const_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+struct visitor<bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor0.
+ *
+ * The following template arguments are used:
+ * - @e T_return The return type of operator()().
+ * - @e T_obj The object type.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj>
+class bound_volatile_mem_functor0
+ : public volatile_mem_functor0<T_return, T_obj>
+{
+ typedef volatile_mem_functor0<T_return, T_obj> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_volatile_mem_functor0 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_volatile_mem_functor0( T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_volatile_mem_functor0 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_volatile_mem_functor0( T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()() const
+ { return (obj_.invoke().*(this->func_ptr_))(); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ volatile_limit_reference<T_obj> 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_volatile_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_volatile_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj>
+struct visitor<bound_volatile_mem_functor0<T_return, T_obj> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_volatile_mem_functor0<T_return, T_obj>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor1.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 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 T_return, class T_obj, class T_arg1>
+class bound_volatile_mem_functor1
+ : public volatile_mem_functor1<T_return, T_obj, T_arg1>
+{
+ typedef volatile_mem_functor1<T_return, T_obj, T_arg1> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_volatile_mem_functor1 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_volatile_mem_functor1( T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_volatile_mem_functor1 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_volatile_mem_functor1( T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1) const
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ volatile_limit_reference<T_obj> 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_volatile_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_volatile_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj, class T_arg1>
+struct visitor<bound_volatile_mem_functor1<T_return, T_obj, T_arg1> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor2.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 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 T_return, class T_obj, class T_arg1, class T_arg2>
+class bound_volatile_mem_functor2
+ : public volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
+{
+ typedef volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_volatile_mem_functor2 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_volatile_mem_functor2( T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_volatile_mem_functor2 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_volatile_mem_functor2( T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ volatile_limit_reference<T_obj> 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_volatile_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_volatile_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj, class T_arg1, class T_arg2>
+struct visitor<bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor3.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
+class bound_volatile_mem_functor3
+ : public volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
+{
+ typedef volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_volatile_mem_functor3 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_volatile_mem_functor3( T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_volatile_mem_functor3 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_volatile_mem_functor3( T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ volatile_limit_reference<T_obj> 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_volatile_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_volatile_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
+struct visitor<bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor4.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+class bound_volatile_mem_functor4
+ : public volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
+{
+ typedef volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_volatile_mem_functor4 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_volatile_mem_functor4( T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_volatile_mem_functor4 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_volatile_mem_functor4( T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ volatile_limit_reference<T_obj> 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_volatile_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_volatile_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+struct visitor<bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor5.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 Argument type used in the definition of operator()().
+ * - @e T_arg5 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+class bound_volatile_mem_functor5
+ : public volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+{
+ typedef volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_volatile_mem_functor5 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_volatile_mem_functor5( T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_volatile_mem_functor5 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_volatile_mem_functor5( T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ volatile_limit_reference<T_obj> 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_volatile_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_volatile_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+struct visitor<bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor6.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 Argument type used in the definition of operator()().
+ * - @e T_arg5 Argument type used in the definition of operator()().
+ * - @e T_arg6 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+class bound_volatile_mem_functor6
+ : public volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+{
+ typedef volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_volatile_mem_functor6 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_volatile_mem_functor6( T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_volatile_mem_functor6 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_volatile_mem_functor6( T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @param _A_a6 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ volatile_limit_reference<T_obj> 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_volatile_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_volatile_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+struct visitor<bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor7.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 Argument type used in the definition of operator()().
+ * - @e T_arg5 Argument type used in the definition of operator()().
+ * - @e T_arg6 Argument type used in the definition of operator()().
+ * - @e T_arg7 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+class bound_volatile_mem_functor7
+ : public volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+{
+ typedef volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_volatile_mem_functor7 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_volatile_mem_functor7( T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_volatile_mem_functor7 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_volatile_mem_functor7( T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @param _A_a6 Argument to be passed on to the method.
+ * @param _A_a7 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ volatile_limit_reference<T_obj> 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_volatile_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_volatile_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+struct visitor<bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor0.
+ *
+ * The following template arguments are used:
+ * - @e T_return The return type of operator()().
+ * - @e T_obj The object type.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj>
+class bound_const_volatile_mem_functor0
+ : public const_volatile_mem_functor0<T_return, T_obj>
+{
+ typedef const_volatile_mem_functor0<T_return, T_obj> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_const_volatile_mem_functor0 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_const_volatile_mem_functor0(const T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_const_volatile_mem_functor0 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_const_volatile_mem_functor0(const T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()() const
+ { return (obj_.invoke().*(this->func_ptr_))(); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_volatile_limit_reference<T_obj> 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_const_volatile_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj>
+struct visitor<bound_const_volatile_mem_functor0<T_return, T_obj> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_const_volatile_mem_functor0<T_return, T_obj>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor1.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 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 T_return, class T_obj, class T_arg1>
+class bound_const_volatile_mem_functor1
+ : public const_volatile_mem_functor1<T_return, T_obj, T_arg1>
+{
+ typedef const_volatile_mem_functor1<T_return, T_obj, T_arg1> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_const_volatile_mem_functor1 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_const_volatile_mem_functor1(const T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_const_volatile_mem_functor1 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_const_volatile_mem_functor1(const T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1) const
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_volatile_limit_reference<T_obj> 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_const_volatile_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj, class T_arg1>
+struct visitor<bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor2.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 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 T_return, class T_obj, class T_arg1, class T_arg2>
+class bound_const_volatile_mem_functor2
+ : public const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
+{
+ typedef const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_const_volatile_mem_functor2 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_const_volatile_mem_functor2(const T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_const_volatile_mem_functor2 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_const_volatile_mem_functor2(const T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_volatile_limit_reference<T_obj> 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_const_volatile_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj, class T_arg1, class T_arg2>
+struct visitor<bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor3.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
+class bound_const_volatile_mem_functor3
+ : public const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
+{
+ typedef const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_const_volatile_mem_functor3 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_const_volatile_mem_functor3(const T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_const_volatile_mem_functor3 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_const_volatile_mem_functor3(const T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_volatile_limit_reference<T_obj> 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_const_volatile_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
+struct visitor<bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor4.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+class bound_const_volatile_mem_functor4
+ : public const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
+{
+ typedef const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_const_volatile_mem_functor4 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_const_volatile_mem_functor4(const T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_const_volatile_mem_functor4 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_const_volatile_mem_functor4(const T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_volatile_limit_reference<T_obj> 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_const_volatile_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+struct visitor<bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor5.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 Argument type used in the definition of operator()().
+ * - @e T_arg5 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+class bound_const_volatile_mem_functor5
+ : public const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+{
+ typedef const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_const_volatile_mem_functor5 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_const_volatile_mem_functor5(const T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_const_volatile_mem_functor5 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_const_volatile_mem_functor5(const T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_volatile_limit_reference<T_obj> 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_const_volatile_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+struct visitor<bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor6.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 Argument type used in the definition of operator()().
+ * - @e T_arg5 Argument type used in the definition of operator()().
+ * - @e T_arg6 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+class bound_const_volatile_mem_functor6
+ : public const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+{
+ typedef const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_const_volatile_mem_functor6 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_const_volatile_mem_functor6(const T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_const_volatile_mem_functor6 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_const_volatile_mem_functor6(const T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @param _A_a6 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_volatile_limit_reference<T_obj> 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_const_volatile_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+struct visitor<bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor7.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 Argument type used in the definition of operator()().
+ * - @e T_arg5 Argument type used in the definition of operator()().
+ * - @e T_arg6 Argument type used in the definition of operator()().
+ * - @e T_arg7 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 T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+class bound_const_volatile_mem_functor7
+ : public const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+{
+ typedef const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> base_type_;
+public:
+ typedef typename base_type_::function_type function_type;
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Constructs a bound_const_volatile_mem_functor7 object that wraps the passed method.
+ *
+ * @deprecated Please use the constructor that takes the object by reference
+ * instead.
+ *
+ * @param _A_obj Pointer to instance the method will operate on.
+ * @param _A_func Pointer to method will be invoked from operator()().
+ */
+ bound_const_volatile_mem_functor7(const T_obj* _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Constructs a bound_const_volatile_mem_functor7 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_const_volatile_mem_functor7(const T_obj& _A_obj, function_type _A_func)
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
+
+ /** Execute the wrapped method operating on the stored instance.
+ * @param _A_a1 Argument to be passed on to the method.
+ * @param _A_a2 Argument to be passed on to the method.
+ * @param _A_a3 Argument to be passed on to the method.
+ * @param _A_a4 Argument to be passed on to the method.
+ * @param _A_a5 Argument to be passed on to the method.
+ * @param _A_a6 Argument to be passed on to the method.
+ * @param _A_a7 Argument to be passed on to the method.
+ * @return The return value of the method invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
+
+//protected:
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_volatile_limit_reference<T_obj> 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_const_volatile_mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+struct visitor<bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.obj_);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+// numbered
+/** Creates a functor of type sigc::mem_functor0 which wraps a method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj>
+inline mem_functor0<T_return, T_obj>
+mem_fun0(T_return (T_obj::*_A_func)() )
+{ return mem_functor0<T_return, T_obj>(_A_func); }
+
+/** Creates a functor of type sigc::mem_functor1 which wraps a method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_return, class T_obj>
+inline mem_functor1<T_return, T_obj, T_arg1>
+mem_fun1(T_return (T_obj::*_A_func)(T_arg1) )
+{ return mem_functor1<T_return, T_obj, T_arg1>(_A_func); }
+
+/** Creates a functor of type sigc::mem_functor2 which wraps a method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_return, class T_obj>
+inline mem_functor2<T_return, T_obj, T_arg1, T_arg2>
+mem_fun2(T_return (T_obj::*_A_func)(T_arg1, T_arg2) )
+{ return mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_func); }
+
+/** Creates a functor of type sigc::mem_functor3 which wraps a method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
+inline mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
+mem_fun3(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3) )
+{ return mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_func); }
+
+/** Creates a functor of type sigc::mem_functor4 which wraps a method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
+inline mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
+mem_fun4(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) )
+{ return mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_func); }
+
+/** Creates a functor of type sigc::mem_functor5 which wraps a method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
+inline mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+mem_fun5(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) )
+{ return mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_func); }
+
+/** Creates a functor of type sigc::mem_functor6 which wraps a method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj>
+inline mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+mem_fun6(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) )
+{ return mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_func); }
+
+/** Creates a functor of type sigc::mem_functor7 which wraps a method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj>
+inline mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+mem_fun7(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) )
+{ return mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_func); }
+
+/** Creates a functor of type sigc::const_mem_functor0 which wraps a const method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj>
+inline const_mem_functor0<T_return, T_obj>
+mem_fun0(T_return (T_obj::*_A_func)() const)
+{ return const_mem_functor0<T_return, T_obj>(_A_func); }
+
+/** Creates a functor of type sigc::const_mem_functor1 which wraps a const method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_return, class T_obj>
+inline const_mem_functor1<T_return, T_obj, T_arg1>
+mem_fun1(T_return (T_obj::*_A_func)(T_arg1) const)
+{ return const_mem_functor1<T_return, T_obj, T_arg1>(_A_func); }
+
+/** Creates a functor of type sigc::const_mem_functor2 which wraps a const method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_return, class T_obj>
+inline const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
+mem_fun2(T_return (T_obj::*_A_func)(T_arg1, T_arg2) const)
+{ return const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_func); }
+
+/** Creates a functor of type sigc::const_mem_functor3 which wraps a const method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
+inline const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
+mem_fun3(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3) const)
+{ return const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_func); }
+
+/** Creates a functor of type sigc::const_mem_functor4 which wraps a const method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
+inline const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
+mem_fun4(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)
+{ return const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_func); }
+
+/** Creates a functor of type sigc::const_mem_functor5 which wraps a const method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
+inline const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+mem_fun5(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)
+{ return const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_func); }
+
+/** Creates a functor of type sigc::const_mem_functor6 which wraps a const method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj>
+inline const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+mem_fun6(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)
+{ return const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_func); }
+
+/** Creates a functor of type sigc::const_mem_functor7 which wraps a const method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj>
+inline const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+mem_fun7(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)
+{ return const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_func); }
+
+/** Creates a functor of type sigc::volatile_mem_functor0 which wraps a volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj>
+inline volatile_mem_functor0<T_return, T_obj>
+mem_fun0(T_return (T_obj::*_A_func)() volatile)
+{ return volatile_mem_functor0<T_return, T_obj>(_A_func); }
+
+/** Creates a functor of type sigc::volatile_mem_functor1 which wraps a volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_return, class T_obj>
+inline volatile_mem_functor1<T_return, T_obj, T_arg1>
+mem_fun1(T_return (T_obj::*_A_func)(T_arg1) volatile)
+{ return volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_func); }
+
+/** Creates a functor of type sigc::volatile_mem_functor2 which wraps a volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_return, class T_obj>
+inline volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
+mem_fun2(T_return (T_obj::*_A_func)(T_arg1, T_arg2) volatile)
+{ return volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_func); }
+
+/** Creates a functor of type sigc::volatile_mem_functor3 which wraps a volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
+inline volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
+mem_fun3(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3) volatile)
+{ return volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_func); }
+
+/** Creates a functor of type sigc::volatile_mem_functor4 which wraps a volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
+inline volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
+mem_fun4(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)
+{ return volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_func); }
+
+/** Creates a functor of type sigc::volatile_mem_functor5 which wraps a volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
+inline volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+mem_fun5(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)
+{ return volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_func); }
+
+/** Creates a functor of type sigc::volatile_mem_functor6 which wraps a volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj>
+inline volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+mem_fun6(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)
+{ return volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_func); }
+
+/** Creates a functor of type sigc::volatile_mem_functor7 which wraps a volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj>
+inline volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+mem_fun7(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)
+{ return volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_func); }
+
+/** Creates a functor of type sigc::const_volatile_mem_functor0 which wraps a const volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj>
+inline const_volatile_mem_functor0<T_return, T_obj>
+mem_fun0(T_return (T_obj::*_A_func)() const volatile)
+{ return const_volatile_mem_functor0<T_return, T_obj>(_A_func); }
+
+/** Creates a functor of type sigc::const_volatile_mem_functor1 which wraps a const volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_return, class T_obj>
+inline const_volatile_mem_functor1<T_return, T_obj, T_arg1>
+mem_fun1(T_return (T_obj::*_A_func)(T_arg1) const volatile)
+{ return const_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_func); }
+
+/** Creates a functor of type sigc::const_volatile_mem_functor2 which wraps a const volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_return, class T_obj>
+inline const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
+mem_fun2(T_return (T_obj::*_A_func)(T_arg1, T_arg2) const volatile)
+{ return const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_func); }
+
+/** Creates a functor of type sigc::const_volatile_mem_functor3 which wraps a const volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
+inline const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
+mem_fun3(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3) const volatile)
+{ return const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_func); }
+
+/** Creates a functor of type sigc::const_volatile_mem_functor4 which wraps a const volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
+inline const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
+mem_fun4(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)
+{ return const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_func); }
+
+/** Creates a functor of type sigc::const_volatile_mem_functor5 which wraps a const volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
+inline const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+mem_fun5(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)
+{ return const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_func); }
+
+/** Creates a functor of type sigc::const_volatile_mem_functor6 which wraps a const volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj>
+inline const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+mem_fun6(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)
+{ return const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_func); }
+
+/** Creates a functor of type sigc::const_volatile_mem_functor7 which wraps a const volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj>
+inline const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+mem_fun7(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)
+{ return const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_mem_functor0 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor0<T_return, T_obj>
+mem_fun0(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)() )
+{ return bound_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_mem_functor0 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 <class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor0<T_return, T_obj>
+mem_fun0(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)() )
+{ return bound_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_mem_functor1 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor1<T_return, T_obj, T_arg1>
+mem_fun1(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1) )
+{ return bound_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_mem_functor1 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 <class T_arg1, class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor1<T_return, T_obj, T_arg1>
+mem_fun1(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1) )
+{ return bound_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_mem_functor2 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
+mem_fun2(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) )
+{ return bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_mem_functor2 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 <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
+mem_fun2(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) )
+{ return bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_mem_functor3 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
+mem_fun3(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) )
+{ return bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_mem_functor3 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 <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
+mem_fun3(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) )
+{ return bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_mem_functor4 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
+mem_fun4(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) )
+{ return bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_mem_functor4 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
+mem_fun4(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) )
+{ return bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_mem_functor5 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+mem_fun5(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) )
+{ return bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_mem_functor5 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+mem_fun5(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) )
+{ return bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_mem_functor6 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+mem_fun6(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) )
+{ return bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_mem_functor6 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+mem_fun6(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) )
+{ return bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_mem_functor7 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+mem_fun7(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) )
+{ return bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_mem_functor7 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+mem_fun7(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) )
+{ return bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_mem_functor0 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor0<T_return, T_obj>
+mem_fun0(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)() const)
+{ return bound_const_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_mem_functor0 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 <class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor0<T_return, T_obj>
+mem_fun0(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)() const)
+{ return bound_const_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_mem_functor1 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor1<T_return, T_obj, T_arg1>
+mem_fun1(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1) const)
+{ return bound_const_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_mem_functor1 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 <class T_arg1, class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor1<T_return, T_obj, T_arg1>
+mem_fun1(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1) const)
+{ return bound_const_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_mem_functor2 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
+mem_fun2(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) const)
+{ return bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_mem_functor2 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 <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
+mem_fun2(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) const)
+{ return bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_mem_functor3 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
+mem_fun3(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const)
+{ return bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_mem_functor3 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 <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
+mem_fun3(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const)
+{ return bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_mem_functor4 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
+mem_fun4(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)
+{ return bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_mem_functor4 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
+mem_fun4(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)
+{ return bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_mem_functor5 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+mem_fun5(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)
+{ return bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_mem_functor5 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+mem_fun5(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)
+{ return bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_mem_functor6 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+mem_fun6(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)
+{ return bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_mem_functor6 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+mem_fun6(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)
+{ return bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_mem_functor7 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+mem_fun7(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)
+{ return bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_mem_functor7 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+mem_fun7(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)
+{ return bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_volatile_mem_functor0 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor0<T_return, T_obj>
+mem_fun0(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)() volatile)
+{ return bound_volatile_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_volatile_mem_functor0 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 <class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor0<T_return, T_obj>
+mem_fun0(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)() volatile)
+{ return bound_volatile_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_volatile_mem_functor1 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor1<T_return, T_obj, T_arg1>
+mem_fun1(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1) volatile)
+{ return bound_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_volatile_mem_functor1 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 <class T_arg1, class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor1<T_return, T_obj, T_arg1>
+mem_fun1(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1) volatile)
+{ return bound_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_volatile_mem_functor2 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
+mem_fun2(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) volatile)
+{ return bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_volatile_mem_functor2 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 <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
+mem_fun2(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) volatile)
+{ return bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_volatile_mem_functor3 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
+mem_fun3(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) volatile)
+{ return bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_volatile_mem_functor3 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 <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
+mem_fun3(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) volatile)
+{ return bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_volatile_mem_functor4 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
+mem_fun4(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)
+{ return bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_volatile_mem_functor4 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
+mem_fun4(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)
+{ return bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_volatile_mem_functor5 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+mem_fun5(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)
+{ return bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_volatile_mem_functor5 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+mem_fun5(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)
+{ return bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_volatile_mem_functor6 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+mem_fun6(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)
+{ return bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_volatile_mem_functor6 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+mem_fun6(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)
+{ return bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_volatile_mem_functor7 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+mem_fun7(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)
+{ return bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_volatile_mem_functor7 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+mem_fun7(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)
+{ return bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor0 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor0<T_return, T_obj>
+mem_fun0(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)() const volatile)
+{ return bound_const_volatile_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor0 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 <class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor0<T_return, T_obj>
+mem_fun0(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)() const volatile)
+{ return bound_const_volatile_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor1 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>
+mem_fun1(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1) const volatile)
+{ return bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor1 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 <class T_arg1, class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>
+mem_fun1(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1) const volatile)
+{ return bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor2 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
+mem_fun2(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) const volatile)
+{ return bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor2 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 <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
+mem_fun2(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) const volatile)
+{ return bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor3 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
+mem_fun3(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const volatile)
+{ return bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor3 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 <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
+mem_fun3(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const volatile)
+{ return bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor4 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
+mem_fun4(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)
+{ return bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor4 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
+mem_fun4(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)
+{ return bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor5 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+mem_fun5(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)
+{ return bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor5 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+mem_fun5(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)
+{ return bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor6 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+mem_fun6(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)
+{ return bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor6 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+mem_fun6(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)
+{ return bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor7 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+mem_fun7(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)
+{ return bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor7 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+mem_fun7(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)
+{ return bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
+
+
+// unnumbered
+/** Creates a functor of type sigc::mem_functor0 which wraps a method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj>
+inline mem_functor0<T_return, T_obj>
+mem_fun(T_return (T_obj::*_A_func)() )
+{ return mem_functor0<T_return, T_obj>(_A_func); }
+
+/** Creates a functor of type sigc::mem_functor1 which wraps a method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_return, class T_obj>
+inline mem_functor1<T_return, T_obj, T_arg1>
+mem_fun(T_return (T_obj::*_A_func)(T_arg1) )
+{ return mem_functor1<T_return, T_obj, T_arg1>(_A_func); }
+
+/** Creates a functor of type sigc::mem_functor2 which wraps a method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_return, class T_obj>
+inline mem_functor2<T_return, T_obj, T_arg1, T_arg2>
+mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2) )
+{ return mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_func); }
+
+/** Creates a functor of type sigc::mem_functor3 which wraps a method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
+inline mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
+mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3) )
+{ return mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_func); }
+
+/** Creates a functor of type sigc::mem_functor4 which wraps a method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
+inline mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
+mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) )
+{ return mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_func); }
+
+/** Creates a functor of type sigc::mem_functor5 which wraps a method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
+inline mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) )
+{ return mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_func); }
+
+/** Creates a functor of type sigc::mem_functor6 which wraps a method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj>
+inline mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) )
+{ return mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_func); }
+
+/** Creates a functor of type sigc::mem_functor7 which wraps a method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj>
+inline mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) )
+{ return mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_func); }
+
+/** Creates a functor of type sigc::const_mem_functor0 which wraps a const method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj>
+inline const_mem_functor0<T_return, T_obj>
+mem_fun(T_return (T_obj::*_A_func)() const)
+{ return const_mem_functor0<T_return, T_obj>(_A_func); }
+
+/** Creates a functor of type sigc::const_mem_functor1 which wraps a const method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_return, class T_obj>
+inline const_mem_functor1<T_return, T_obj, T_arg1>
+mem_fun(T_return (T_obj::*_A_func)(T_arg1) const)
+{ return const_mem_functor1<T_return, T_obj, T_arg1>(_A_func); }
+
+/** Creates a functor of type sigc::const_mem_functor2 which wraps a const method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_return, class T_obj>
+inline const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
+mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2) const)
+{ return const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_func); }
+
+/** Creates a functor of type sigc::const_mem_functor3 which wraps a const method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
+inline const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
+mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3) const)
+{ return const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_func); }
+
+/** Creates a functor of type sigc::const_mem_functor4 which wraps a const method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
+inline const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
+mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)
+{ return const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_func); }
+
+/** Creates a functor of type sigc::const_mem_functor5 which wraps a const method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
+inline const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)
+{ return const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_func); }
+
+/** Creates a functor of type sigc::const_mem_functor6 which wraps a const method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj>
+inline const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)
+{ return const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_func); }
+
+/** Creates a functor of type sigc::const_mem_functor7 which wraps a const method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj>
+inline const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)
+{ return const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_func); }
+
+/** Creates a functor of type sigc::volatile_mem_functor0 which wraps a volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj>
+inline volatile_mem_functor0<T_return, T_obj>
+mem_fun(T_return (T_obj::*_A_func)() volatile)
+{ return volatile_mem_functor0<T_return, T_obj>(_A_func); }
+
+/** Creates a functor of type sigc::volatile_mem_functor1 which wraps a volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_return, class T_obj>
+inline volatile_mem_functor1<T_return, T_obj, T_arg1>
+mem_fun(T_return (T_obj::*_A_func)(T_arg1) volatile)
+{ return volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_func); }
+
+/** Creates a functor of type sigc::volatile_mem_functor2 which wraps a volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_return, class T_obj>
+inline volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
+mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2) volatile)
+{ return volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_func); }
+
+/** Creates a functor of type sigc::volatile_mem_functor3 which wraps a volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
+inline volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
+mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3) volatile)
+{ return volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_func); }
+
+/** Creates a functor of type sigc::volatile_mem_functor4 which wraps a volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
+inline volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
+mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)
+{ return volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_func); }
+
+/** Creates a functor of type sigc::volatile_mem_functor5 which wraps a volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
+inline volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)
+{ return volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_func); }
+
+/** Creates a functor of type sigc::volatile_mem_functor6 which wraps a volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj>
+inline volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)
+{ return volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_func); }
+
+/** Creates a functor of type sigc::volatile_mem_functor7 which wraps a volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj>
+inline volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)
+{ return volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_func); }
+
+/** Creates a functor of type sigc::const_volatile_mem_functor0 which wraps a const volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_return, class T_obj>
+inline const_volatile_mem_functor0<T_return, T_obj>
+mem_fun(T_return (T_obj::*_A_func)() const volatile)
+{ return const_volatile_mem_functor0<T_return, T_obj>(_A_func); }
+
+/** Creates a functor of type sigc::const_volatile_mem_functor1 which wraps a const volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_return, class T_obj>
+inline const_volatile_mem_functor1<T_return, T_obj, T_arg1>
+mem_fun(T_return (T_obj::*_A_func)(T_arg1) const volatile)
+{ return const_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_func); }
+
+/** Creates a functor of type sigc::const_volatile_mem_functor2 which wraps a const volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_return, class T_obj>
+inline const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
+mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2) const volatile)
+{ return const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_func); }
+
+/** Creates a functor of type sigc::const_volatile_mem_functor3 which wraps a const volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
+inline const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
+mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3) const volatile)
+{ return const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_func); }
+
+/** Creates a functor of type sigc::const_volatile_mem_functor4 which wraps a const volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
+inline const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
+mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)
+{ return const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_func); }
+
+/** Creates a functor of type sigc::const_volatile_mem_functor5 which wraps a const volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
+inline const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)
+{ return const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_func); }
+
+/** Creates a functor of type sigc::const_volatile_mem_functor6 which wraps a const volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj>
+inline const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)
+{ return const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_func); }
+
+/** Creates a functor of type sigc::const_volatile_mem_functor7 which wraps a const volatile method.
+ * @param _A_func Pointer to method that should be wrapped.
+ * @return Functor that executes _A_func on invokation.
+ *
+ * @ingroup mem_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj>
+inline const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)
+{ return const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_mem_functor0 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor0<T_return, T_obj>
+mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)() )
+{ return bound_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_mem_functor0 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 <class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor0<T_return, T_obj>
+mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)() )
+{ return bound_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_mem_functor1 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor1<T_return, T_obj, T_arg1>
+mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1) )
+{ return bound_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_mem_functor1 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 <class T_arg1, class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor1<T_return, T_obj, T_arg1>
+mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1) )
+{ return bound_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_mem_functor2 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
+mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) )
+{ return bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_mem_functor2 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 <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
+mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) )
+{ return bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_mem_functor3 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
+mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) )
+{ return bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_mem_functor3 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 <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
+mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) )
+{ return bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_mem_functor4 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
+mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) )
+{ return bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_mem_functor4 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
+mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) )
+{ return bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_mem_functor5 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) )
+{ return bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_mem_functor5 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) )
+{ return bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_mem_functor6 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) )
+{ return bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_mem_functor6 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) )
+{ return bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_mem_functor7 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) )
+{ return bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_mem_functor7 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
+inline bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) )
+{ return bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_mem_functor0 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor0<T_return, T_obj>
+mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)() const)
+{ return bound_const_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_mem_functor0 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 <class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor0<T_return, T_obj>
+mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)() const)
+{ return bound_const_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_mem_functor1 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor1<T_return, T_obj, T_arg1>
+mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1) const)
+{ return bound_const_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_mem_functor1 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 <class T_arg1, class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor1<T_return, T_obj, T_arg1>
+mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1) const)
+{ return bound_const_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_mem_functor2 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
+mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) const)
+{ return bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_mem_functor2 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 <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
+mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) const)
+{ return bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_mem_functor3 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
+mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const)
+{ return bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_mem_functor3 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 <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
+mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const)
+{ return bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_mem_functor4 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
+mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)
+{ return bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_mem_functor4 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
+mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)
+{ return bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_mem_functor5 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)
+{ return bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_mem_functor5 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)
+{ return bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_mem_functor6 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)
+{ return bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_mem_functor6 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)
+{ return bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_mem_functor7 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)
+{ return bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_mem_functor7 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
+inline bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)
+{ return bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_volatile_mem_functor0 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor0<T_return, T_obj>
+mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)() volatile)
+{ return bound_volatile_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_volatile_mem_functor0 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 <class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor0<T_return, T_obj>
+mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)() volatile)
+{ return bound_volatile_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_volatile_mem_functor1 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor1<T_return, T_obj, T_arg1>
+mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1) volatile)
+{ return bound_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_volatile_mem_functor1 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 <class T_arg1, class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor1<T_return, T_obj, T_arg1>
+mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1) volatile)
+{ return bound_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_volatile_mem_functor2 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
+mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) volatile)
+{ return bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_volatile_mem_functor2 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 <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
+mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) volatile)
+{ return bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_volatile_mem_functor3 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
+mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) volatile)
+{ return bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_volatile_mem_functor3 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 <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
+mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) volatile)
+{ return bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_volatile_mem_functor4 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
+mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)
+{ return bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_volatile_mem_functor4 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
+mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)
+{ return bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_volatile_mem_functor5 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)
+{ return bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_volatile_mem_functor5 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)
+{ return bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_volatile_mem_functor6 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)
+{ return bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_volatile_mem_functor6 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)
+{ return bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_volatile_mem_functor7 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)
+{ return bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_volatile_mem_functor7 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
+inline bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)
+{ return bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor0 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor0<T_return, T_obj>
+mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)() const volatile)
+{ return bound_const_volatile_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor0 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 <class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor0<T_return, T_obj>
+mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)() const volatile)
+{ return bound_const_volatile_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor1 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>
+mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1) const volatile)
+{ return bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor1 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 <class T_arg1, class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>
+mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1) const volatile)
+{ return bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor2 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
+mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) const volatile)
+{ return bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor2 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 <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
+mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) const volatile)
+{ return bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor3 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
+mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const volatile)
+{ return bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor3 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 <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
+mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const volatile)
+{ return bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor4 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
+mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)
+{ return bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor4 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
+mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)
+{ return bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor5 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)
+{ return bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor5 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)
+{ return bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor6 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)
+{ return bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor6 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)
+{ return bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor7 which encapsulates a method and an object instance.
+ *
+ * @deprecated Please use the version that takes the object by reference instead.
+ *
+ * @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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)
+{ return bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
+#endif //SIGCXX_DISABLE_DEPRECATED
+
+/** Creates a functor of type sigc::bound_const_volatile_mem_functor7 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
+inline bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)
+{ return bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
+
+
+} /* namespace sigc */
+#endif /* _SIGC_FUNCTORS_MEM_FUN_H_ */
--- /dev/null
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+
+#ifndef _SIGC_FUNCTORS_PTR_FUN_H_
+#define _SIGC_FUNCTORS_PTR_FUN_H_
+#include <sigc++/type_traits.h>
+#include <sigc++/functors/functor_trait.h>
+
+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<void, int> 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<void, long> sl = sigc::ptr_fun1<int>(&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<void, int> sl = sigc::ptr_fun(&foo::bar);
+ * @endcode
+ *
+ * @ingroup sigcfunctors
+ */
+
+/** pointer_functor0 wraps existing non-member functions with 0 argument(s).
+ * Use the convenience function ptr_fun() to create an instance of pointer_functor0.
+ *
+ * The following template arguments are used:
+ * - @e T_return The return type of operator()().
+ *
+ * @ingroup ptr_fun
+ */
+template <class T_return>
+class pointer_functor0 : public functor_base
+{
+ typedef T_return (*function_type)();
+protected:
+ function_type func_ptr_;
+public:
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ pointer_functor0() {}
+
+ /** Constructs a pointer_functor0 object that wraps an existing function.
+ * @param _A_func Pointer to function that will be invoked from operator()().
+ */
+ explicit pointer_functor0(function_type _A_func): func_ptr_(_A_func) {}
+
+ /** Execute the wrapped function.
+ * @return The return value of the function invocation.
+ */
+ T_return operator()() const
+ { return func_ptr_(); }
+};
+
+/** pointer_functor1 wraps existing non-member functions with 1 argument(s).
+ * Use the convenience function ptr_fun() to create an instance of pointer_functor1.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_return The return type of operator()().
+ *
+ * @ingroup ptr_fun
+ */
+template <class T_arg1, class T_return>
+class pointer_functor1 : public functor_base
+{
+ typedef T_return (*function_type)(T_arg1);
+protected:
+ function_type func_ptr_;
+public:
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ pointer_functor1() {}
+
+ /** Constructs a pointer_functor1 object that wraps an existing function.
+ * @param _A_func Pointer to function that will be invoked from operator()().
+ */
+ explicit pointer_functor1(function_type _A_func): func_ptr_(_A_func) {}
+
+ /** Execute the wrapped function.
+ * @param _A_a1 Argument to be passed on to the function.
+ * @return The return value of the function invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1) const
+ { return func_ptr_(_A_a1); }
+};
+
+/** pointer_functor2 wraps existing non-member functions with 2 argument(s).
+ * Use the convenience function ptr_fun() to create an instance of pointer_functor2.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_return The return type of operator()().
+ *
+ * @ingroup ptr_fun
+ */
+template <class T_arg1, class T_arg2, class T_return>
+class pointer_functor2 : public functor_base
+{
+ typedef T_return (*function_type)(T_arg1, T_arg2);
+protected:
+ function_type func_ptr_;
+public:
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ pointer_functor2() {}
+
+ /** Constructs a pointer_functor2 object that wraps an existing function.
+ * @param _A_func Pointer to function that will be invoked from operator()().
+ */
+ explicit pointer_functor2(function_type _A_func): func_ptr_(_A_func) {}
+
+ /** Execute the wrapped function.
+ * @param _A_a1 Argument to be passed on to the function.
+ * @param _A_a2 Argument to be passed on to the function.
+ * @return The return value of the function invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
+ { return func_ptr_(_A_a1, _A_a2); }
+};
+
+/** pointer_functor3 wraps existing non-member functions with 3 argument(s).
+ * Use the convenience function ptr_fun() to create an instance of pointer_functor3.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_return The return type of operator()().
+ *
+ * @ingroup ptr_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_return>
+class pointer_functor3 : public functor_base
+{
+ typedef T_return (*function_type)(T_arg1, T_arg2, T_arg3);
+protected:
+ function_type func_ptr_;
+public:
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ pointer_functor3() {}
+
+ /** Constructs a pointer_functor3 object that wraps an existing function.
+ * @param _A_func Pointer to function that will be invoked from operator()().
+ */
+ explicit pointer_functor3(function_type _A_func): func_ptr_(_A_func) {}
+
+ /** Execute the wrapped function.
+ * @param _A_a1 Argument to be passed on to the function.
+ * @param _A_a2 Argument to be passed on to the function.
+ * @param _A_a3 Argument to be passed on to the function.
+ * @return The return value of the function invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
+ { return func_ptr_(_A_a1, _A_a2, _A_a3); }
+};
+
+/** pointer_functor4 wraps existing non-member functions with 4 argument(s).
+ * Use the convenience function ptr_fun() to create an instance of pointer_functor4.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 Argument type used in the definition of operator()().
+ * - @e T_return The return type of operator()().
+ *
+ * @ingroup ptr_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return>
+class pointer_functor4 : public functor_base
+{
+ typedef T_return (*function_type)(T_arg1, T_arg2, T_arg3, T_arg4);
+protected:
+ function_type func_ptr_;
+public:
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ pointer_functor4() {}
+
+ /** Constructs a pointer_functor4 object that wraps an existing function.
+ * @param _A_func Pointer to function that will be invoked from operator()().
+ */
+ explicit pointer_functor4(function_type _A_func): func_ptr_(_A_func) {}
+
+ /** Execute the wrapped function.
+ * @param _A_a1 Argument to be passed on to the function.
+ * @param _A_a2 Argument to be passed on to the function.
+ * @param _A_a3 Argument to be passed on to the function.
+ * @param _A_a4 Argument to be passed on to the function.
+ * @return The return value of the function invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
+ { return func_ptr_(_A_a1, _A_a2, _A_a3, _A_a4); }
+};
+
+/** pointer_functor5 wraps existing non-member functions with 5 argument(s).
+ * Use the convenience function ptr_fun() to create an instance of pointer_functor5.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 Argument type used in the definition of operator()().
+ * - @e T_arg5 Argument type used in the definition of operator()().
+ * - @e T_return The return type of operator()().
+ *
+ * @ingroup ptr_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return>
+class pointer_functor5 : public functor_base
+{
+ typedef T_return (*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5);
+protected:
+ function_type func_ptr_;
+public:
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ pointer_functor5() {}
+
+ /** Constructs a pointer_functor5 object that wraps an existing function.
+ * @param _A_func Pointer to function that will be invoked from operator()().
+ */
+ explicit pointer_functor5(function_type _A_func): func_ptr_(_A_func) {}
+
+ /** Execute the wrapped function.
+ * @param _A_a1 Argument to be passed on to the function.
+ * @param _A_a2 Argument to be passed on to the function.
+ * @param _A_a3 Argument to be passed on to the function.
+ * @param _A_a4 Argument to be passed on to the function.
+ * @param _A_a5 Argument to be passed on to the function.
+ * @return The return value of the function invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
+ { return func_ptr_(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
+};
+
+/** pointer_functor6 wraps existing non-member functions with 6 argument(s).
+ * Use the convenience function ptr_fun() to create an instance of pointer_functor6.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 Argument type used in the definition of operator()().
+ * - @e T_arg5 Argument type used in the definition of operator()().
+ * - @e T_arg6 Argument type used in the definition of operator()().
+ * - @e T_return The return type of operator()().
+ *
+ * @ingroup ptr_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return>
+class pointer_functor6 : public functor_base
+{
+ typedef T_return (*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6);
+protected:
+ function_type func_ptr_;
+public:
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ pointer_functor6() {}
+
+ /** Constructs a pointer_functor6 object that wraps an existing function.
+ * @param _A_func Pointer to function that will be invoked from operator()().
+ */
+ explicit pointer_functor6(function_type _A_func): func_ptr_(_A_func) {}
+
+ /** Execute the wrapped function.
+ * @param _A_a1 Argument to be passed on to the function.
+ * @param _A_a2 Argument to be passed on to the function.
+ * @param _A_a3 Argument to be passed on to the function.
+ * @param _A_a4 Argument to be passed on to the function.
+ * @param _A_a5 Argument to be passed on to the function.
+ * @param _A_a6 Argument to be passed on to the function.
+ * @return The return value of the function invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
+ { return func_ptr_(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
+};
+
+/** pointer_functor7 wraps existing non-member functions with 7 argument(s).
+ * Use the convenience function ptr_fun() to create an instance of pointer_functor7.
+ *
+ * The following template arguments are used:
+ * - @e T_arg1 Argument type used in the definition of operator()().
+ * - @e T_arg2 Argument type used in the definition of operator()().
+ * - @e T_arg3 Argument type used in the definition of operator()().
+ * - @e T_arg4 Argument type used in the definition of operator()().
+ * - @e T_arg5 Argument type used in the definition of operator()().
+ * - @e T_arg6 Argument type used in the definition of operator()().
+ * - @e T_arg7 Argument type used in the definition of operator()().
+ * - @e T_return The return type of operator()().
+ *
+ * @ingroup ptr_fun
+ */
+template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return>
+class pointer_functor7 : public functor_base
+{
+ typedef T_return (*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7);
+protected:
+ function_type func_ptr_;
+public:
+ typedef T_return result_type;
+
+ /// Constructs an invalid functor.
+ pointer_functor7() {}
+
+ /** Constructs a pointer_functor7 object that wraps an existing function.
+ * @param _A_func Pointer to function that will be invoked from operator()().
+ */
+ explicit pointer_functor7(function_type _A_func): func_ptr_(_A_func) {}
+
+ /** Execute the wrapped function.
+ * @param _A_a1 Argument to be passed on to the function.
+ * @param _A_a2 Argument to be passed on to the function.
+ * @param _A_a3 Argument to be passed on to the function.
+ * @param _A_a4 Argument to be passed on to the function.
+ * @param _A_a5 Argument to be passed on to the function.
+ * @param _A_a6 Argument to be passed on to the function.
+ * @param _A_a7 Argument to be passed on to the function.
+ * @return The return value of the function invocation.
+ */
+ T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
+ { return func_ptr_(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
+};
+
+
+// numbered ptr_fun
+/** Creates a functor of type sigc::pointer_functor0 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 <class T_return>
+inline pointer_functor0<T_return>
+ptr_fun0(T_return (*_A_func)())
+{ return pointer_functor0<T_return>(_A_func); }
+
+/** Creates a functor of type sigc::pointer_functor1 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 <class T_arg1, class T_return>
+inline pointer_functor1<T_arg1, T_return>
+ptr_fun1(T_return (*_A_func)(T_arg1))
+{ return pointer_functor1<T_arg1, T_return>(_A_func); }
+
+/** Creates a functor of type sigc::pointer_functor2 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 <class T_arg1, class T_arg2, class T_return>
+inline pointer_functor2<T_arg1, T_arg2, T_return>
+ptr_fun2(T_return (*_A_func)(T_arg1, T_arg2))
+{ return pointer_functor2<T_arg1, T_arg2, T_return>(_A_func); }
+
+/** Creates a functor of type sigc::pointer_functor3 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 <class T_arg1, class T_arg2, class T_arg3, class T_return>
+inline pointer_functor3<T_arg1, T_arg2, T_arg3, T_return>
+ptr_fun3(T_return (*_A_func)(T_arg1, T_arg2, T_arg3))
+{ return pointer_functor3<T_arg1, T_arg2, T_arg3, T_return>(_A_func); }
+
+/** Creates a functor of type sigc::pointer_functor4 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return>
+inline pointer_functor4<T_arg1, T_arg2, T_arg3, T_arg4, T_return>
+ptr_fun4(T_return (*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4))
+{ return pointer_functor4<T_arg1, T_arg2, T_arg3, T_arg4, T_return>(_A_func); }
+
+/** Creates a functor of type sigc::pointer_functor5 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return>
+inline pointer_functor5<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return>
+ptr_fun5(T_return (*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))
+{ return pointer_functor5<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return>(_A_func); }
+
+/** Creates a functor of type sigc::pointer_functor6 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return>
+inline pointer_functor6<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return>
+ptr_fun6(T_return (*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))
+{ return pointer_functor6<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return>(_A_func); }
+
+/** Creates a functor of type sigc::pointer_functor7 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return>
+inline pointer_functor7<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return>
+ptr_fun7(T_return (*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))
+{ return pointer_functor7<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return>(_A_func); }
+
+
+// unnumbered ptr_fun
+/** Creates a functor of type sigc::pointer_functor0 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 <class T_return>
+inline pointer_functor0<T_return>
+ptr_fun(T_return (*_A_func)())
+{ return pointer_functor0<T_return>(_A_func); }
+
+/** Creates a functor of type sigc::pointer_functor1 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 <class T_arg1, class T_return>
+inline pointer_functor1<T_arg1, T_return>
+ptr_fun(T_return (*_A_func)(T_arg1))
+{ return pointer_functor1<T_arg1, T_return>(_A_func); }
+
+/** Creates a functor of type sigc::pointer_functor2 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 <class T_arg1, class T_arg2, class T_return>
+inline pointer_functor2<T_arg1, T_arg2, T_return>
+ptr_fun(T_return (*_A_func)(T_arg1, T_arg2))
+{ return pointer_functor2<T_arg1, T_arg2, T_return>(_A_func); }
+
+/** Creates a functor of type sigc::pointer_functor3 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 <class T_arg1, class T_arg2, class T_arg3, class T_return>
+inline pointer_functor3<T_arg1, T_arg2, T_arg3, T_return>
+ptr_fun(T_return (*_A_func)(T_arg1, T_arg2, T_arg3))
+{ return pointer_functor3<T_arg1, T_arg2, T_arg3, T_return>(_A_func); }
+
+/** Creates a functor of type sigc::pointer_functor4 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return>
+inline pointer_functor4<T_arg1, T_arg2, T_arg3, T_arg4, T_return>
+ptr_fun(T_return (*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4))
+{ return pointer_functor4<T_arg1, T_arg2, T_arg3, T_arg4, T_return>(_A_func); }
+
+/** Creates a functor of type sigc::pointer_functor5 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return>
+inline pointer_functor5<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return>
+ptr_fun(T_return (*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))
+{ return pointer_functor5<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return>(_A_func); }
+
+/** Creates a functor of type sigc::pointer_functor6 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return>
+inline pointer_functor6<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return>
+ptr_fun(T_return (*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))
+{ return pointer_functor6<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return>(_A_func); }
+
+/** Creates a functor of type sigc::pointer_functor7 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return>
+inline pointer_functor7<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return>
+ptr_fun(T_return (*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))
+{ return pointer_functor7<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return>(_A_func); }
+
+
+} /* namespace sigc */
+#endif /* _SIGC_FUNCTORS_PTR_FUN_H_ */
--- /dev/null
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+#ifndef _SIGC_FUNCTORS_SLOT_H_
+#define _SIGC_FUNCTORS_SLOT_H_
+#include <sigc++/trackable.h>
+#include <sigc++/visit_each.h>
+#include <sigc++/adaptors/adaptor_trait.h>
+#include <sigc++/functors/slot_base.h>
+
+//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 {
+
+// 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 <typename T_out, typename T_in>
+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<T_out>(reinterpret_cast<void (*)()>(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 <class T_functor>
+struct typed_slot_rep : public slot_rep
+{
+ typedef typed_slot_rep<T_functor> 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<T_functor>::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<trackable*>(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<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;
+
+ inline ~typed_slot_rep()
+ {
+ call_ = nullptr;
+ destroy_ = nullptr;
+ sigc::visit_each_type<trackable*>(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<self*>(reinterpret_cast<slot_rep*>(data));
+ self_->call_ = nullptr;
+ self_->destroy_ = nullptr;
+ sigc::visit_each_type<trackable*>(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<slot_rep*>(data);
+ return static_cast<slot_rep*>(new self(*static_cast<self*>(a_rep)));
+ }
+};
+
+/** 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().
+ *
+ */
+template<class T_functor, class T_return>
+struct slot_call0
+{
+ /** Invokes a functor of type @p T_functor.
+ * @param rep slot_rep object that holds a functor of type @p T_functor.
+ * @return The return values of the functor invocation.
+ */
+ static T_return call_it(slot_rep* rep)
+ {
+ typedef typed_slot_rep<T_functor> typed_slot;
+ typed_slot *typed_rep = static_cast<typed_slot*>(rep);
+ return (typed_rep->functor_)();
+ }
+
+ /** Forms a function pointer from call_it().
+ * @return A function pointer formed from call_it().
+ */
+ static hook address()
+ { return sigc::internal::function_pointer_cast<hook>(&call_it); }
+};
+
+/** 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_arg1 Argument type used in the definition of call_it().
+ *
+ */
+template<class T_functor, class T_return, class T_arg1>
+struct slot_call1
+{
+ /** Invokes a functor of type @p T_functor.
+ * @param rep slot_rep object that holds a functor of type @p T_functor.
+ * @param _A_a1 Argument 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<T_arg1> a_1)
+ {
+ typedef typed_slot_rep<T_functor> typed_slot;
+ typed_slot *typed_rep = static_cast<typed_slot*>(rep);
+ return (typed_rep->functor_).SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_arg1>>
+ (a_1);
+ }
+
+ /** Forms a function pointer from call_it().
+ * @return A function pointer formed from call_it().
+ */
+ static hook address()
+ { return sigc::internal::function_pointer_cast<hook>(&call_it); }
+};
+
+/** 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_arg1 Argument type used in the definition of call_it().
+ * - @e T_arg2 Argument type used in the definition of call_it().
+ *
+ */
+template<class T_functor, class T_return, class T_arg1, class T_arg2>
+struct slot_call2
+{
+ /** Invokes a functor of type @p T_functor.
+ * @param rep slot_rep object that holds a functor of type @p T_functor.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument 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<T_arg1> a_1, type_trait_take_t<T_arg2> a_2)
+ {
+ typedef typed_slot_rep<T_functor> typed_slot;
+ typed_slot *typed_rep = static_cast<typed_slot*>(rep);
+ return (typed_rep->functor_).SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>>
+ (a_1, a_2);
+ }
+
+ /** Forms a function pointer from call_it().
+ * @return A function pointer formed from call_it().
+ */
+ static hook address()
+ { return sigc::internal::function_pointer_cast<hook>(&call_it); }
+};
+
+/** 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_arg1 Argument type used in the definition of call_it().
+ * - @e T_arg2 Argument type used in the definition of call_it().
+ * - @e T_arg3 Argument type used in the definition of call_it().
+ *
+ */
+template<class T_functor, class T_return, class T_arg1, class T_arg2, class T_arg3>
+struct slot_call3
+{
+ /** Invokes a functor of type @p T_functor.
+ * @param rep slot_rep object that holds a functor of type @p T_functor.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument 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<T_arg1> a_1, type_trait_take_t<T_arg2> a_2, type_trait_take_t<T_arg3> a_3)
+ {
+ typedef typed_slot_rep<T_functor> typed_slot;
+ typed_slot *typed_rep = static_cast<typed_slot*>(rep);
+ return (typed_rep->functor_).SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>, type_trait_take_t<T_arg3>>
+ (a_1, a_2, a_3);
+ }
+
+ /** Forms a function pointer from call_it().
+ * @return A function pointer formed from call_it().
+ */
+ static hook address()
+ { return sigc::internal::function_pointer_cast<hook>(&call_it); }
+};
+
+/** 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_arg1 Argument type used in the definition of call_it().
+ * - @e T_arg2 Argument type used in the definition of call_it().
+ * - @e T_arg3 Argument type used in the definition of call_it().
+ * - @e T_arg4 Argument type used in the definition of call_it().
+ *
+ */
+template<class T_functor, class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+struct slot_call4
+{
+ /** Invokes a functor of type @p T_functor.
+ * @param rep slot_rep object that holds a functor of type @p T_functor.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument 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<T_arg1> a_1, type_trait_take_t<T_arg2> a_2, type_trait_take_t<T_arg3> a_3, type_trait_take_t<T_arg4> a_4)
+ {
+ typedef typed_slot_rep<T_functor> typed_slot;
+ typed_slot *typed_rep = static_cast<typed_slot*>(rep);
+ return (typed_rep->functor_).SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>, type_trait_take_t<T_arg3>, type_trait_take_t<T_arg4>>
+ (a_1, a_2, a_3, a_4);
+ }
+
+ /** Forms a function pointer from call_it().
+ * @return A function pointer formed from call_it().
+ */
+ static hook address()
+ { return sigc::internal::function_pointer_cast<hook>(&call_it); }
+};
+
+/** 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_arg1 Argument type used in the definition of call_it().
+ * - @e T_arg2 Argument type used in the definition of call_it().
+ * - @e T_arg3 Argument type used in the definition of call_it().
+ * - @e T_arg4 Argument type used in the definition of call_it().
+ * - @e T_arg5 Argument type used in the definition of call_it().
+ *
+ */
+template<class T_functor, class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+struct slot_call5
+{
+ /** Invokes a functor of type @p T_functor.
+ * @param rep slot_rep object that holds a functor of type @p T_functor.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @param _A_a5 Argument 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<T_arg1> a_1, type_trait_take_t<T_arg2> a_2, type_trait_take_t<T_arg3> a_3, type_trait_take_t<T_arg4> a_4, type_trait_take_t<T_arg5> a_5)
+ {
+ typedef typed_slot_rep<T_functor> typed_slot;
+ typed_slot *typed_rep = static_cast<typed_slot*>(rep);
+ return (typed_rep->functor_).SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>, type_trait_take_t<T_arg3>, type_trait_take_t<T_arg4>, type_trait_take_t<T_arg5>>
+ (a_1, a_2, a_3, a_4, a_5);
+ }
+
+ /** Forms a function pointer from call_it().
+ * @return A function pointer formed from call_it().
+ */
+ static hook address()
+ { return sigc::internal::function_pointer_cast<hook>(&call_it); }
+};
+
+/** 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_arg1 Argument type used in the definition of call_it().
+ * - @e T_arg2 Argument type used in the definition of call_it().
+ * - @e T_arg3 Argument type used in the definition of call_it().
+ * - @e T_arg4 Argument type used in the definition of call_it().
+ * - @e T_arg5 Argument type used in the definition of call_it().
+ * - @e T_arg6 Argument type used in the definition of call_it().
+ *
+ */
+template<class T_functor, class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+struct slot_call6
+{
+ /** Invokes a functor of type @p T_functor.
+ * @param rep slot_rep object that holds a functor of type @p T_functor.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @param _A_a5 Argument to be passed on to the functor.
+ * @param _A_a6 Argument 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<T_arg1> a_1, type_trait_take_t<T_arg2> a_2, type_trait_take_t<T_arg3> a_3, type_trait_take_t<T_arg4> a_4, type_trait_take_t<T_arg5> a_5, type_trait_take_t<T_arg6> a_6)
+ {
+ typedef typed_slot_rep<T_functor> typed_slot;
+ typed_slot *typed_rep = static_cast<typed_slot*>(rep);
+ return (typed_rep->functor_).SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>, type_trait_take_t<T_arg3>, type_trait_take_t<T_arg4>, type_trait_take_t<T_arg5>, type_trait_take_t<T_arg6>>
+ (a_1, a_2, a_3, a_4, a_5, a_6);
+ }
+
+ /** Forms a function pointer from call_it().
+ * @return A function pointer formed from call_it().
+ */
+ static hook address()
+ { return sigc::internal::function_pointer_cast<hook>(&call_it); }
+};
+
+/** 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_arg1 Argument type used in the definition of call_it().
+ * - @e T_arg2 Argument type used in the definition of call_it().
+ * - @e T_arg3 Argument type used in the definition of call_it().
+ * - @e T_arg4 Argument type used in the definition of call_it().
+ * - @e T_arg5 Argument type used in the definition of call_it().
+ * - @e T_arg6 Argument type used in the definition of call_it().
+ * - @e T_arg7 Argument type used in the definition of call_it().
+ *
+ */
+template<class T_functor, class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+struct slot_call7
+{
+ /** Invokes a functor of type @p T_functor.
+ * @param rep slot_rep object that holds a functor of type @p T_functor.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @param _A_a5 Argument to be passed on to the functor.
+ * @param _A_a6 Argument to be passed on to the functor.
+ * @param _A_a7 Argument 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<T_arg1> a_1, type_trait_take_t<T_arg2> a_2, type_trait_take_t<T_arg3> a_3, type_trait_take_t<T_arg4> a_4, type_trait_take_t<T_arg5> a_5, type_trait_take_t<T_arg6> a_6, type_trait_take_t<T_arg7> a_7)
+ {
+ typedef typed_slot_rep<T_functor> typed_slot;
+ typed_slot *typed_rep = static_cast<typed_slot*>(rep);
+ return (typed_rep->functor_).SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>, type_trait_take_t<T_arg3>, type_trait_take_t<T_arg4>, type_trait_take_t<T_arg5>, type_trait_take_t<T_arg6>, type_trait_take_t<T_arg7>>
+ (a_1, a_2, a_3, a_4, a_5, a_6, a_7);
+ }
+
+ /** Forms a function pointer from call_it().
+ * @return A function pointer formed from call_it().
+ */
+ static hook address()
+ { return sigc::internal::function_pointer_cast<hook>(&call_it); }
+};
+
+
+/** 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<class T_functor, class T_return, class... T_arg>
+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_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<T_arg>... a_)
+ {
+ using typed_slot = typed_slot_rep<T_functor>;
+ typed_slot *typed_rep = static_cast<typed_slot*>(rep);
+ return (typed_rep->functor_).SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_arg>...>
+ (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<hook>(&call_it); }
+};
+
+/** Abstracts functor execution.
+ * call_it() invokes a functor without parameters of type @e T_functor.
+ * address() forms a function pointer from call_it().
+ *
+ * This is a specialization for functors without parameters.
+ *
+ * The following template arguments are used:
+ * - @e T_functor The functor type.
+ * - @e T_return The return type of call_it().
+ *
+ */
+template<class T_functor, class T_return>
+struct slot_call<T_functor, T_return>
+{
+ /** Invokes a functor of type @p T_functor.
+ * @param rep slot_rep object that holds a functor of type @p T_functor.
+ * @return The return values of the functor invocation.
+ */
+ static T_return call_it(slot_rep* rep)
+ {
+ using typed_slot = typed_slot_rep<T_functor>;
+ typed_slot *typed_rep = static_cast<typed_slot*>(rep);
+ return (typed_rep->functor_)();
+ }
+
+ /** Forms a function pointer from call_it().
+ * @return A function pointer formed from call_it().
+ */
+ static hook address()
+ { return sigc::internal::function_pointer_cast<hook>(&call_it); }
+};
+
+} /* namespace internal */
+
+
+/** 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()().
+ *
+ * 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 T_return>
+class slot0
+ : public slot_base
+{
+public:
+ typedef T_return result_type;
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+private:
+ typedef internal::slot_rep rep_type;
+public:
+ typedef T_return (*call_type)(rep_type*);
+#endif
+
+ /** Invoke the contained functor unless slot is in blocking state.
+ * @return The return value of the functor invocation.
+ */
+ inline T_return operator()() const
+ {
+ if (!empty() && !blocked())
+ return (sigc::internal::function_pointer_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_);
+ return T_return();
+ }
+
+ inline slot0() {}
+
+ /** Constructs a slot from an arbitrary functor.
+ * @param _A_func The desired functor the new slot should be assigned to.
+ */
+ template <class T_functor>
+ slot0(const T_functor& _A_func)
+ : slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
+ {
+ //The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
+ slot_base::rep_->call_ = internal::slot_call0<T_functor, T_return>::address();
+ }
+
+ /** Constructs a slot, copying an existing one.
+ * @param src The existing slot to copy.
+ */
+ slot0(const slot0& 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.
+ */
+ slot0(slot0&& 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.
+ */
+ slot0& operator=(const slot0& 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.
+ */
+ slot0& operator=(slot0&& 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::slot0 are similar to the function
+ * overloads for sigc::slot. See the description of those overloads.
+ *
+ * @ingroup slot
+ */
+template <typename T_return>
+struct visitor<slot0<T_return>>
+{
+ static void do_visit_each(const internal::limit_derived_target<trackable*, internal::slot_do_bind>& _A_action,
+ const slot0<T_return>& _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<trackable*, internal::slot_do_unbind>& _A_action,
+ const slot0<T_return>& _A_target)
+ {
+ if (_A_target.rep_ && _A_target.rep_->parent_ == _A_action.action_.rep_)
+ _A_target.rep_->set_parent(nullptr, nullptr);
+ }
+
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const slot0<T_return>& _A_target)
+ {
+ _A_action(_A_target);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** 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_arg1 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 T_return, class T_arg1>
+class slot1
+ : public slot_base
+{
+public:
+ typedef T_return result_type;
+ typedef type_trait_take_t<T_arg1> arg1_type_;
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+private:
+ typedef internal::slot_rep rep_type;
+public:
+ typedef T_return (*call_type)(rep_type*, arg1_type_);
+#endif
+
+ /** Invoke the contained functor unless slot is in blocking state.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ inline T_return operator()(arg1_type_ _A_a1) const
+ {
+ if (!empty() && !blocked())
+ return (sigc::internal::function_pointer_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a1);
+ return T_return();
+ }
+
+ inline slot1() {}
+
+ /** Constructs a slot from an arbitrary functor.
+ * @param _A_func The desired functor the new slot should be assigned to.
+ */
+ template <class T_functor>
+ slot1(const T_functor& _A_func)
+ : slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
+ {
+ //The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
+ slot_base::rep_->call_ = internal::slot_call1<T_functor, T_return, T_arg1>::address();
+ }
+
+ /** Constructs a slot, copying an existing one.
+ * @param src The existing slot to copy.
+ */
+ slot1(const slot1& 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.
+ */
+ slot1(slot1&& 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.
+ */
+ slot1& operator=(const slot1& 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.
+ */
+ slot1& operator=(slot1&& 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::slot1 are similar to the function
+ * overloads for sigc::slot. See the description of those overloads.
+ *
+ * @ingroup slot
+ */
+template <typename T_return, typename T_arg1>
+struct visitor<slot1<T_return, T_arg1>>
+{
+ static void do_visit_each(const internal::limit_derived_target<trackable*, internal::slot_do_bind>& _A_action,
+ const slot1<T_return, T_arg1>& _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<trackable*, internal::slot_do_unbind>& _A_action,
+ const slot1<T_return, T_arg1>& _A_target)
+ {
+ if (_A_target.rep_ && _A_target.rep_->parent_ == _A_action.action_.rep_)
+ _A_target.rep_->set_parent(nullptr, nullptr);
+ }
+
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const slot1<T_return, T_arg1>& _A_target)
+ {
+ _A_action(_A_target);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** 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_arg1 Argument type used in the definition of operator()(). The default @p nil means no argument.
+ * - @e T_arg2 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 T_return, class T_arg1, class T_arg2>
+class slot2
+ : public slot_base
+{
+public:
+ typedef T_return result_type;
+ typedef type_trait_take_t<T_arg1> arg1_type_;
+ typedef type_trait_take_t<T_arg2> arg2_type_;
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+private:
+ typedef internal::slot_rep rep_type;
+public:
+ typedef T_return (*call_type)(rep_type*, arg1_type_, arg2_type_);
+#endif
+
+ /** Invoke the contained functor unless slot is in blocking state.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ inline T_return operator()(arg1_type_ _A_a1, arg2_type_ _A_a2) const
+ {
+ if (!empty() && !blocked())
+ return (sigc::internal::function_pointer_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a1, _A_a2);
+ return T_return();
+ }
+
+ inline slot2() {}
+
+ /** Constructs a slot from an arbitrary functor.
+ * @param _A_func The desired functor the new slot should be assigned to.
+ */
+ template <class T_functor>
+ slot2(const T_functor& _A_func)
+ : slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
+ {
+ //The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
+ slot_base::rep_->call_ = internal::slot_call2<T_functor, T_return, T_arg1, T_arg2>::address();
+ }
+
+ /** Constructs a slot, copying an existing one.
+ * @param src The existing slot to copy.
+ */
+ slot2(const slot2& 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.
+ */
+ slot2(slot2&& 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.
+ */
+ slot2& operator=(const slot2& 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.
+ */
+ slot2& operator=(slot2&& 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::slot2 are similar to the function
+ * overloads for sigc::slot. See the description of those overloads.
+ *
+ * @ingroup slot
+ */
+template <typename T_return, typename T_arg1, typename T_arg2>
+struct visitor<slot2<T_return, T_arg1, T_arg2>>
+{
+ static void do_visit_each(const internal::limit_derived_target<trackable*, internal::slot_do_bind>& _A_action,
+ const slot2<T_return, T_arg1, T_arg2>& _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<trackable*, internal::slot_do_unbind>& _A_action,
+ const slot2<T_return, T_arg1, T_arg2>& _A_target)
+ {
+ if (_A_target.rep_ && _A_target.rep_->parent_ == _A_action.action_.rep_)
+ _A_target.rep_->set_parent(nullptr, nullptr);
+ }
+
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const slot2<T_return, T_arg1, T_arg2>& _A_target)
+ {
+ _A_action(_A_target);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** 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_arg1 Argument type used in the definition of operator()(). The default @p nil means no argument.
+ * - @e T_arg2 Argument type used in the definition of operator()(). The default @p nil means no argument.
+ * - @e T_arg3 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 T_return, class T_arg1, class T_arg2, class T_arg3>
+class slot3
+ : public slot_base
+{
+public:
+ typedef T_return result_type;
+ typedef type_trait_take_t<T_arg1> arg1_type_;
+ typedef type_trait_take_t<T_arg2> arg2_type_;
+ typedef type_trait_take_t<T_arg3> arg3_type_;
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+private:
+ typedef internal::slot_rep rep_type;
+public:
+ typedef T_return (*call_type)(rep_type*, arg1_type_, arg2_type_, arg3_type_);
+#endif
+
+ /** Invoke the contained functor unless slot is in blocking state.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ inline T_return operator()(arg1_type_ _A_a1, arg2_type_ _A_a2, arg3_type_ _A_a3) const
+ {
+ if (!empty() && !blocked())
+ return (sigc::internal::function_pointer_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a1, _A_a2, _A_a3);
+ return T_return();
+ }
+
+ inline slot3() {}
+
+ /** Constructs a slot from an arbitrary functor.
+ * @param _A_func The desired functor the new slot should be assigned to.
+ */
+ template <class T_functor>
+ slot3(const T_functor& _A_func)
+ : slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
+ {
+ //The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
+ slot_base::rep_->call_ = internal::slot_call3<T_functor, T_return, T_arg1, T_arg2, T_arg3>::address();
+ }
+
+ /** Constructs a slot, copying an existing one.
+ * @param src The existing slot to copy.
+ */
+ slot3(const slot3& 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.
+ */
+ slot3(slot3&& 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.
+ */
+ slot3& operator=(const slot3& 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.
+ */
+ slot3& operator=(slot3&& 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::slot3 are similar to the function
+ * overloads for sigc::slot. See the description of those overloads.
+ *
+ * @ingroup slot
+ */
+template <typename T_return, typename T_arg1, typename T_arg2, typename T_arg3>
+struct visitor<slot3<T_return, T_arg1, T_arg2, T_arg3>>
+{
+ static void do_visit_each(const internal::limit_derived_target<trackable*, internal::slot_do_bind>& _A_action,
+ const slot3<T_return, T_arg1, T_arg2, T_arg3>& _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<trackable*, internal::slot_do_unbind>& _A_action,
+ const slot3<T_return, T_arg1, T_arg2, T_arg3>& _A_target)
+ {
+ if (_A_target.rep_ && _A_target.rep_->parent_ == _A_action.action_.rep_)
+ _A_target.rep_->set_parent(nullptr, nullptr);
+ }
+
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const slot3<T_return, T_arg1, T_arg2, T_arg3>& _A_target)
+ {
+ _A_action(_A_target);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** 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_arg1 Argument type used in the definition of operator()(). The default @p nil means no argument.
+ * - @e T_arg2 Argument type used in the definition of operator()(). The default @p nil means no argument.
+ * - @e T_arg3 Argument type used in the definition of operator()(). The default @p nil means no argument.
+ * - @e T_arg4 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 T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+class slot4
+ : public slot_base
+{
+public:
+ typedef T_return result_type;
+ typedef type_trait_take_t<T_arg1> arg1_type_;
+ typedef type_trait_take_t<T_arg2> arg2_type_;
+ typedef type_trait_take_t<T_arg3> arg3_type_;
+ typedef type_trait_take_t<T_arg4> arg4_type_;
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+private:
+ typedef internal::slot_rep rep_type;
+public:
+ typedef T_return (*call_type)(rep_type*, arg1_type_, arg2_type_, arg3_type_, arg4_type_);
+#endif
+
+ /** Invoke the contained functor unless slot is in blocking state.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ inline T_return operator()(arg1_type_ _A_a1, arg2_type_ _A_a2, arg3_type_ _A_a3, arg4_type_ _A_a4) const
+ {
+ if (!empty() && !blocked())
+ return (sigc::internal::function_pointer_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a1, _A_a2, _A_a3, _A_a4);
+ return T_return();
+ }
+
+ inline slot4() {}
+
+ /** Constructs a slot from an arbitrary functor.
+ * @param _A_func The desired functor the new slot should be assigned to.
+ */
+ template <class T_functor>
+ slot4(const T_functor& _A_func)
+ : slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
+ {
+ //The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
+ slot_base::rep_->call_ = internal::slot_call4<T_functor, T_return, T_arg1, T_arg2, T_arg3, T_arg4>::address();
+ }
+
+ /** Constructs a slot, copying an existing one.
+ * @param src The existing slot to copy.
+ */
+ slot4(const slot4& 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.
+ */
+ slot4(slot4&& 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.
+ */
+ slot4& operator=(const slot4& 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.
+ */
+ slot4& operator=(slot4&& 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::slot4 are similar to the function
+ * overloads for sigc::slot. See the description of those overloads.
+ *
+ * @ingroup slot
+ */
+template <typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
+struct visitor<slot4<T_return, T_arg1, T_arg2, T_arg3, T_arg4>>
+{
+ static void do_visit_each(const internal::limit_derived_target<trackable*, internal::slot_do_bind>& _A_action,
+ const slot4<T_return, T_arg1, T_arg2, T_arg3, T_arg4>& _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<trackable*, internal::slot_do_unbind>& _A_action,
+ const slot4<T_return, T_arg1, T_arg2, T_arg3, T_arg4>& _A_target)
+ {
+ if (_A_target.rep_ && _A_target.rep_->parent_ == _A_action.action_.rep_)
+ _A_target.rep_->set_parent(nullptr, nullptr);
+ }
+
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const slot4<T_return, T_arg1, T_arg2, T_arg3, T_arg4>& _A_target)
+ {
+ _A_action(_A_target);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** 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_arg1 Argument type used in the definition of operator()(). The default @p nil means no argument.
+ * - @e T_arg2 Argument type used in the definition of operator()(). The default @p nil means no argument.
+ * - @e T_arg3 Argument type used in the definition of operator()(). The default @p nil means no argument.
+ * - @e T_arg4 Argument type used in the definition of operator()(). The default @p nil means no argument.
+ * - @e T_arg5 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 T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+class slot5
+ : public slot_base
+{
+public:
+ typedef T_return result_type;
+ typedef type_trait_take_t<T_arg1> arg1_type_;
+ typedef type_trait_take_t<T_arg2> arg2_type_;
+ typedef type_trait_take_t<T_arg3> arg3_type_;
+ typedef type_trait_take_t<T_arg4> arg4_type_;
+ typedef type_trait_take_t<T_arg5> arg5_type_;
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+private:
+ typedef internal::slot_rep rep_type;
+public:
+ typedef T_return (*call_type)(rep_type*, arg1_type_, arg2_type_, arg3_type_, arg4_type_, arg5_type_);
+#endif
+
+ /** Invoke the contained functor unless slot is in blocking state.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @param _A_a5 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ inline T_return operator()(arg1_type_ _A_a1, arg2_type_ _A_a2, arg3_type_ _A_a3, arg4_type_ _A_a4, arg5_type_ _A_a5) const
+ {
+ if (!empty() && !blocked())
+ return (sigc::internal::function_pointer_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5);
+ return T_return();
+ }
+
+ inline slot5() {}
+
+ /** Constructs a slot from an arbitrary functor.
+ * @param _A_func The desired functor the new slot should be assigned to.
+ */
+ template <class T_functor>
+ slot5(const T_functor& _A_func)
+ : slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
+ {
+ //The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
+ slot_base::rep_->call_ = internal::slot_call5<T_functor, T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::address();
+ }
+
+ /** Constructs a slot, copying an existing one.
+ * @param src The existing slot to copy.
+ */
+ slot5(const slot5& 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.
+ */
+ slot5(slot5&& 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.
+ */
+ slot5& operator=(const slot5& 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.
+ */
+ slot5& operator=(slot5&& 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::slot5 are similar to the function
+ * overloads for sigc::slot. See the description of those overloads.
+ *
+ * @ingroup slot
+ */
+template <typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
+struct visitor<slot5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>>
+{
+ static void do_visit_each(const internal::limit_derived_target<trackable*, internal::slot_do_bind>& _A_action,
+ const slot5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _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<trackable*, internal::slot_do_unbind>& _A_action,
+ const slot5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_target)
+ {
+ if (_A_target.rep_ && _A_target.rep_->parent_ == _A_action.action_.rep_)
+ _A_target.rep_->set_parent(nullptr, nullptr);
+ }
+
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const slot5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_target)
+ {
+ _A_action(_A_target);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** 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_arg1 Argument type used in the definition of operator()(). The default @p nil means no argument.
+ * - @e T_arg2 Argument type used in the definition of operator()(). The default @p nil means no argument.
+ * - @e T_arg3 Argument type used in the definition of operator()(). The default @p nil means no argument.
+ * - @e T_arg4 Argument type used in the definition of operator()(). The default @p nil means no argument.
+ * - @e T_arg5 Argument type used in the definition of operator()(). The default @p nil means no argument.
+ * - @e T_arg6 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 T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+class slot6
+ : public slot_base
+{
+public:
+ typedef T_return result_type;
+ typedef type_trait_take_t<T_arg1> arg1_type_;
+ typedef type_trait_take_t<T_arg2> arg2_type_;
+ typedef type_trait_take_t<T_arg3> arg3_type_;
+ typedef type_trait_take_t<T_arg4> arg4_type_;
+ typedef type_trait_take_t<T_arg5> arg5_type_;
+ typedef type_trait_take_t<T_arg6> arg6_type_;
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+private:
+ typedef internal::slot_rep rep_type;
+public:
+ typedef T_return (*call_type)(rep_type*, arg1_type_, arg2_type_, arg3_type_, arg4_type_, arg5_type_, arg6_type_);
+#endif
+
+ /** Invoke the contained functor unless slot is in blocking state.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @param _A_a5 Argument to be passed on to the functor.
+ * @param _A_a6 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ inline T_return operator()(arg1_type_ _A_a1, arg2_type_ _A_a2, arg3_type_ _A_a3, arg4_type_ _A_a4, arg5_type_ _A_a5, arg6_type_ _A_a6) const
+ {
+ if (!empty() && !blocked())
+ return (sigc::internal::function_pointer_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6);
+ return T_return();
+ }
+
+ inline slot6() {}
+
+ /** Constructs a slot from an arbitrary functor.
+ * @param _A_func The desired functor the new slot should be assigned to.
+ */
+ template <class T_functor>
+ slot6(const T_functor& _A_func)
+ : slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
+ {
+ //The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
+ slot_base::rep_->call_ = internal::slot_call6<T_functor, T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::address();
+ }
+
+ /** Constructs a slot, copying an existing one.
+ * @param src The existing slot to copy.
+ */
+ slot6(const slot6& 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.
+ */
+ slot6(slot6&& 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.
+ */
+ slot6& operator=(const slot6& 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.
+ */
+ slot6& operator=(slot6&& 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::slot6 are similar to the function
+ * overloads for sigc::slot. See the description of those overloads.
+ *
+ * @ingroup slot
+ */
+template <typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6>
+struct visitor<slot6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>>
+{
+ static void do_visit_each(const internal::limit_derived_target<trackable*, internal::slot_do_bind>& _A_action,
+ const slot6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _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<trackable*, internal::slot_do_unbind>& _A_action,
+ const slot6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_target)
+ {
+ if (_A_target.rep_ && _A_target.rep_->parent_ == _A_action.action_.rep_)
+ _A_target.rep_->set_parent(nullptr, nullptr);
+ }
+
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const slot6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_target)
+ {
+ _A_action(_A_target);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/** 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_arg1 Argument type used in the definition of operator()(). The default @p nil means no argument.
+ * - @e T_arg2 Argument type used in the definition of operator()(). The default @p nil means no argument.
+ * - @e T_arg3 Argument type used in the definition of operator()(). The default @p nil means no argument.
+ * - @e T_arg4 Argument type used in the definition of operator()(). The default @p nil means no argument.
+ * - @e T_arg5 Argument type used in the definition of operator()(). The default @p nil means no argument.
+ * - @e T_arg6 Argument type used in the definition of operator()(). The default @p nil means no argument.
+ * - @e T_arg7 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 T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+class slot7
+ : public slot_base
+{
+public:
+ typedef T_return result_type;
+ typedef type_trait_take_t<T_arg1> arg1_type_;
+ typedef type_trait_take_t<T_arg2> arg2_type_;
+ typedef type_trait_take_t<T_arg3> arg3_type_;
+ typedef type_trait_take_t<T_arg4> arg4_type_;
+ typedef type_trait_take_t<T_arg5> arg5_type_;
+ typedef type_trait_take_t<T_arg6> arg6_type_;
+ typedef type_trait_take_t<T_arg7> arg7_type_;
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+private:
+ typedef internal::slot_rep rep_type;
+public:
+ typedef T_return (*call_type)(rep_type*, arg1_type_, arg2_type_, arg3_type_, arg4_type_, arg5_type_, arg6_type_, arg7_type_);
+#endif
+
+ /** Invoke the contained functor unless slot is in blocking state.
+ * @param _A_a1 Argument to be passed on to the functor.
+ * @param _A_a2 Argument to be passed on to the functor.
+ * @param _A_a3 Argument to be passed on to the functor.
+ * @param _A_a4 Argument to be passed on to the functor.
+ * @param _A_a5 Argument to be passed on to the functor.
+ * @param _A_a6 Argument to be passed on to the functor.
+ * @param _A_a7 Argument to be passed on to the functor.
+ * @return The return value of the functor invocation.
+ */
+ inline T_return operator()(arg1_type_ _A_a1, arg2_type_ _A_a2, arg3_type_ _A_a3, arg4_type_ _A_a4, arg5_type_ _A_a5, arg6_type_ _A_a6, arg7_type_ _A_a7) const
+ {
+ if (!empty() && !blocked())
+ return (sigc::internal::function_pointer_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7);
+ return T_return();
+ }
+
+ inline slot7() {}
+
+ /** Constructs a slot from an arbitrary functor.
+ * @param _A_func The desired functor the new slot should be assigned to.
+ */
+ template <class T_functor>
+ slot7(const T_functor& _A_func)
+ : slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
+ {
+ //The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
+ slot_base::rep_->call_ = internal::slot_call7<T_functor, T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::address();
+ }
+
+ /** Constructs a slot, copying an existing one.
+ * @param src The existing slot to copy.
+ */
+ slot7(const slot7& 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.
+ */
+ slot7(slot7&& 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.
+ */
+ slot7& operator=(const slot7& 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.
+ */
+ slot7& operator=(slot7&& 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::slot7 are similar to the function
+ * overloads for sigc::slot. See the description of those overloads.
+ *
+ * @ingroup slot
+ */
+template <typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
+struct visitor<slot7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>>
+{
+ static void do_visit_each(const internal::limit_derived_target<trackable*, internal::slot_do_bind>& _A_action,
+ const slot7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _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<trackable*, internal::slot_do_unbind>& _A_action,
+ const slot7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_target)
+ {
+ if (_A_target.rep_ && _A_target.rep_->parent_ == _A_action.action_.rep_)
+ _A_target.rep_->set_parent(nullptr, nullptr);
+ }
+
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const slot7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_target)
+ {
+ _A_action(_A_target);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+
+// 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()().
+ * - @e T_arg1 Argument type used in the definition of operator()(). The default @p nil means no argument.
+ * - @e T_arg2 Argument type used in the definition of operator()(). The default @p nil means no argument.
+ * - @e T_arg3 Argument type used in the definition of operator()(). The default @p nil means no argument.
+ * - @e T_arg4 Argument type used in the definition of operator()(). The default @p nil means no argument.
+ * - @e T_arg5 Argument type used in the definition of operator()(). The default @p nil means no argument.
+ * - @e T_arg6 Argument type used in the definition of operator()(). The default @p nil means no argument.
+ * - @e T_arg7 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<void, int> 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 an unnecessary extra wrapper.
+ *
+ * @deprecated Please use the syntax similar to that used by std::function<>:
+ * @code
+ * sigc::slot<void(bool, int)> some_slot;
+ * @endcode
+ *
+ * @ingroup slot
+ */
+template <class T_return, class T_arg1 = nil, class T_arg2 = nil, class T_arg3 = nil, class T_arg4 = nil, class T_arg5 = nil, class T_arg6 = nil, class T_arg7 = nil>
+class slot
+ : public slot7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
+{
+public:
+ typedef slot7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> 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 <class T_functor>
+ 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<const parent_type&>(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<parent_type&>(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;
+ }
+};
+
+#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 <typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
+struct visitor<slot<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>>
+{
+ static void do_visit_each(const internal::limit_derived_target<trackable*, internal::slot_do_bind>& _A_action,
+ const slot<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _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<trackable*, internal::slot_do_unbind>& _A_action,
+ const slot<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_target)
+ {
+ if (_A_target.rep_ && _A_target.rep_->parent_ == _A_action.action_.rep_)
+ _A_target.rep_->set_parent(nullptr, nullptr);
+ }
+
+ template <typename T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const slot<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_target)
+ {
+ _A_action(_A_target);
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+
+
+/** Convenience wrapper for the numbered sigc::slot0 template.
+ * See the base class for useful methods.
+ * This is the template specialization of the unnumbered sigc::slot
+ * template for 0 argument(s), specialized for different numbers of arguments
+ * This is possible because the template has default (nil) template types.
+ *
+ * @deprecated Please use the syntax similar to that used by std::function<>:
+ * @code
+ * sigc::slot<void(bool, int)> some_slot;
+ * @endcode
+ *
+ */
+template <class T_return>
+class slot <T_return, nil, nil, nil, nil, nil, nil, nil>
+ : public slot0<T_return>
+{
+public:
+ typedef slot0<T_return> 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 <class T_functor>
+ 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<const parent_type&>(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<parent_type&>(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;
+ }
+};
+
+
+
+/** Convenience wrapper for the numbered sigc::slot1 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.
+ *
+ * @deprecated Please use the syntax similar to that used by std::function<>:
+ * @code
+ * sigc::slot<void(bool, int)> some_slot;
+ * @endcode
+ *
+ */
+template <class T_return, class T_arg1>
+class slot <T_return, T_arg1, nil, nil, nil, nil, nil, nil>
+ : public slot1<T_return, T_arg1>
+{
+public:
+ typedef slot1<T_return, T_arg1> 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 <class T_functor>
+ 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<const parent_type&>(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<parent_type&>(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;
+ }
+};
+
+
+
+/** Convenience wrapper for the numbered sigc::slot2 template.
+ * See the base class for useful methods.
+ * This is the template specialization of the unnumbered sigc::slot
+ * template for 2 argument(s), specialized for different numbers of arguments
+ * This is possible because the template has default (nil) template types.
+ *
+ * @deprecated Please use the syntax similar to that used by std::function<>:
+ * @code
+ * sigc::slot<void(bool, int)> some_slot;
+ * @endcode
+ *
+ */
+template <class T_return, class T_arg1, class T_arg2>
+class slot <T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil>
+ : public slot2<T_return, T_arg1, T_arg2>
+{
+public:
+ typedef slot2<T_return, T_arg1, T_arg2> 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 <class T_functor>
+ 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<const parent_type&>(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<parent_type&>(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;
+ }
+};
+
+
+
+/** Convenience wrapper for the numbered sigc::slot3 template.
+ * See the base class for useful methods.
+ * This is the template specialization of the unnumbered sigc::slot
+ * template for 3 argument(s), specialized for different numbers of arguments
+ * This is possible because the template has default (nil) template types.
+ *
+ * @deprecated Please use the syntax similar to that used by std::function<>:
+ * @code
+ * sigc::slot<void(bool, int)> some_slot;
+ * @endcode
+ *
+ */
+template <class T_return, class T_arg1, class T_arg2, class T_arg3>
+class slot <T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil>
+ : public slot3<T_return, T_arg1, T_arg2, T_arg3>
+{
+public:
+ typedef slot3<T_return, T_arg1, T_arg2, T_arg3> 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 <class T_functor>
+ 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<const parent_type&>(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<parent_type&>(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;
+ }
+};
+
+
+
+/** Convenience wrapper for the numbered sigc::slot4 template.
+ * See the base class for useful methods.
+ * This is the template specialization of the unnumbered sigc::slot
+ * template for 4 argument(s), specialized for different numbers of arguments
+ * This is possible because the template has default (nil) template types.
+ *
+ * @deprecated Please use the syntax similar to that used by std::function<>:
+ * @code
+ * sigc::slot<void(bool, int)> some_slot;
+ * @endcode
+ *
+ */
+template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+class slot <T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil>
+ : public slot4<T_return, T_arg1, T_arg2, T_arg3, T_arg4>
+{
+public:
+ typedef slot4<T_return, T_arg1, T_arg2, T_arg3, T_arg4> 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 <class T_functor>
+ 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<const parent_type&>(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<parent_type&>(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;
+ }
+};
+
+
+
+/** Convenience wrapper for the numbered sigc::slot5 template.
+ * See the base class for useful methods.
+ * This is the template specialization of the unnumbered sigc::slot
+ * template for 5 argument(s), specialized for different numbers of arguments
+ * This is possible because the template has default (nil) template types.
+ *
+ * @deprecated Please use the syntax similar to that used by std::function<>:
+ * @code
+ * sigc::slot<void(bool, int)> some_slot;
+ * @endcode
+ *
+ */
+template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+class slot <T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil>
+ : public slot5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
+{
+public:
+ typedef slot5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> 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 <class T_functor>
+ 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<const parent_type&>(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<parent_type&>(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;
+ }
+};
+
+
+
+/** Convenience wrapper for the numbered sigc::slot6 template.
+ * See the base class for useful methods.
+ * This is the template specialization of the unnumbered sigc::slot
+ * template for 6 argument(s), specialized for different numbers of arguments
+ * This is possible because the template has default (nil) template types.
+ *
+ * @deprecated Please use the syntax similar to that used by std::function<>:
+ * @code
+ * sigc::slot<void(bool, int)> some_slot;
+ * @endcode
+ *
+ */
+template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+class slot <T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>
+ : public slot6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
+{
+public:
+ typedef slot6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> 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 <class T_functor>
+ 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<const parent_type&>(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<parent_type&>(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;
+ }
+};
+
+
+
+
+/** 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<void(bool, int)> some_slot;
+ * @endcode
+ *
+ * Alternatively, you may use this syntax:
+ * @code
+ * sigc::slot<void, bool, int> 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
+ */
+template <class T_return, class... T_arg>
+class slot<T_return(T_arg...)>
+ : public slot_base
+{
+public:
+ using result_type = T_return;
+ //TODO: using arg_type_ = type_trait_take_t<T_arg>;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+private:
+ using rep_type = internal::slot_rep;
+public:
+ using call_type = T_return (*)(rep_type*, type_trait_take_t<T_arg>...);
+#endif
+
+ /** Invoke the contained functor unless slot is in blocking state.
+ * @param _A_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<T_arg>... _A_a) const
+ {
+ if (!empty() && !blocked())
+ return (sigc::internal::function_pointer_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a...);
+ return T_return();
+ }
+
+ inline slot() {}
+
+ /** Constructs a slot from an arbitrary functor.
+ * @param _A_func The desired functor the new slot should be assigned to.
+ */
+ template <class T_functor>
+ slot(const T_functor& _A_func)
+ : slot_base(new internal::typed_slot_rep<T_functor>(_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<T_functor, T_return, T_arg...>::address();
+ }
+
+ /** Constructs a slot, copying an existing one.
+ * @param src The existing slot to copy.
+ */
+ slot(const slot& 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(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)
+ {
+ 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& operator=(slot&& src)
+ {
+ slot_base::operator=(std::move(src));
+ return *this;
+ }
+};
+
+} /* namespace sigc */
+
+#ifdef SIGC_NIL_HAS_BEEN_PUSHED
+ #undef SIGC_NIL_HAS_BEEN_PUSHED
+ #pragma pop_macro("nil")
+#endif
+#endif /* _SIGC_FUNCTORS_SLOT_H_ */
--- /dev/null
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+
+
+#ifndef _SIGC_LIMIT_REFERENCE_H_
+#define _SIGC_LIMIT_REFERENCE_H_
+
+#include <sigc++/visit_each.h>
+#include <sigc++/type_traits.h>
+#include <sigc++/trackable.h>
+
+namespace sigc {
+
+/** A limit_reference<Foo> 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 <class T_type,
+ bool I_derives_trackable =
+ std::is_base_of<trackable, T_type>::value>
+class limit_reference
+{
+public:
+ /** Constructor.
+ * @param _A_target The reference to limit.
+ */
+ limit_reference(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 T_type& invoke() const
+ { return visited; }
+
+private:
+ /** The reference.
+ */
+ T_type& visited;
+};
+
+/** limit_reference object for a class that derives from trackable.
+ * - @e T_type The type of the reference.
+ */
+template <class T_type>
+class limit_reference<T_type, true>
+{
+public:
+ /** Constructor.
+ * @param _A_target The reference to limit.
+ */
+ limit_reference(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 T_type& invoke() const
+ { return invoked; }
+
+private:
+ /** The trackable reference.
+ */
+ trackable& visited;
+
+ /** The reference.
+ */
+ T_type& invoked;
+};
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+/** Implementation of visitor specialized for the limit_reference
+ * class, to call visit_each() on the entity returned by the 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 <class T_type, bool I_derives_trackable>
+struct visitor<limit_reference<T_type, I_derives_trackable> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const limit_reference<T_type, I_derives_trackable>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.visit());
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+
+/** A const_limit_reference<Foo> 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 <class T_type,
+ bool I_derives_trackable =
+ std::is_base_of<trackable, T_type>::value>
+class const_limit_reference
+{
+public:
+ /** Constructor.
+ * @param _A_target The reference to limit.
+ */
+ const_limit_reference(const 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 const T_type& invoke() const
+ { return visited; }
+
+private:
+ /** The reference.
+ */
+ const T_type& visited;
+};
+
+/** const_limit_reference object for a class that derives from trackable.
+ * - @e T_type The type of the reference.
+ */
+template <class T_type>
+class const_limit_reference<T_type, true>
+{
+public:
+ /** Constructor.
+ * @param _A_target The reference to limit.
+ */
+ const_limit_reference(const 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 const T_type& invoke() const
+ { return invoked; }
+
+private:
+ /** The trackable reference.
+ */
+ const trackable& visited;
+
+ /** The reference.
+ */
+ const T_type& invoked;
+};
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+/** Implementation of visitor specialized for the const_limit_reference
+ * class, to call visit_each() on the entity returned by the const_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 <class T_type, bool I_derives_trackable>
+struct visitor<const_limit_reference<T_type, I_derives_trackable> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const const_limit_reference<T_type, I_derives_trackable>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.visit());
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+
+/** A volatile_limit_reference<Foo> 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 <class T_type,
+ bool I_derives_trackable =
+ std::is_base_of<trackable, T_type>::value>
+class volatile_limit_reference
+{
+public:
+ /** Constructor.
+ * @param _A_target The reference to limit.
+ */
+ volatile_limit_reference(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 volatile T_type& invoke() const
+ { return visited; }
+
+private:
+ /** The reference.
+ */
+ T_type& visited;
+};
+
+/** volatile_limit_reference object for a class that derives from trackable.
+ * - @e T_type The type of the reference.
+ */
+template <class T_type>
+class volatile_limit_reference<T_type, true>
+{
+public:
+ /** Constructor.
+ * @param _A_target The reference to limit.
+ */
+ volatile_limit_reference(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 volatile T_type& invoke() const
+ { return invoked; }
+
+private:
+ /** The trackable reference.
+ */
+ trackable& visited;
+
+ /** The reference.
+ */
+ T_type& invoked;
+};
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+/** Implementation of visitor specialized for the volatile_limit_reference
+ * class, to call visit_each() on the entity returned by the volatile_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 <class T_type, bool I_derives_trackable>
+struct visitor<volatile_limit_reference<T_type, I_derives_trackable> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const volatile_limit_reference<T_type, I_derives_trackable>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.visit());
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+
+/** A const_volatile_limit_reference<Foo> 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 <class T_type,
+ bool I_derives_trackable =
+ std::is_base_of<trackable, T_type>::value>
+class const_volatile_limit_reference
+{
+public:
+ /** Constructor.
+ * @param _A_target The reference to limit.
+ */
+ const_volatile_limit_reference(const 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 const volatile T_type& invoke() const
+ { return visited; }
+
+private:
+ /** The reference.
+ */
+ const T_type& visited;
+};
+
+/** const_volatile_limit_reference object for a class that derives from trackable.
+ * - @e T_type The type of the reference.
+ */
+template <class T_type>
+class const_volatile_limit_reference<T_type, true>
+{
+public:
+ /** Constructor.
+ * @param _A_target The reference to limit.
+ */
+ const_volatile_limit_reference(const 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 const volatile T_type& invoke() const
+ { return invoked; }
+
+private:
+ /** The trackable reference.
+ */
+ const trackable& visited;
+
+ /** The reference.
+ */
+ const T_type& invoked;
+};
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+/** Implementation of visitor specialized for the const_volatile_limit_reference
+ * class, to call visit_each() on the entity returned by the const_volatile_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 <class T_type, bool I_derives_trackable>
+struct visitor<const_volatile_limit_reference<T_type, I_derives_trackable> >
+{
+ template <class T_action>
+ static void do_visit_each(const T_action& _A_action,
+ const const_volatile_limit_reference<T_type, I_derives_trackable>& _A_target)
+ {
+ sigc::visit_each(_A_action, _A_target.visit());
+ }
+};
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+} /* namespace sigc */
+
+#endif /* _SIGC_LIMIT_REFERENCE_H_ */
--- /dev/null
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+
+#ifndef _SIGC_SIGNAL_H_
+#define _SIGC_SIGNAL_H_
+
+#include <list>
+#include <sigc++/signal_base.h>
+#include <sigc++/type_traits.h>
+#include <sigc++/trackable.h>
+#include <sigc++/functors/slot.h>
+#include <sigc++/functors/mem_fun.h>
+
+//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 <typename T_slot>
+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<reference>(*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 <typename T_slot>
+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<reference>(*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.
+ *
+ * @ingroup signal
+ */
+template <class T_slot>
+struct slot_list
+{
+ typedef T_slot slot_type;
+
+ typedef slot_type& reference;
+ typedef const slot_type& const_reference;
+
+ typedef slot_iterator<slot_type> iterator;
+ typedef slot_const_iterator<slot_type> const_iterator;
+
+ #ifndef SIGC_HAVE_SUN_REVERSE_ITERATOR
+ typedef std::reverse_iterator<iterator> reverse_iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+ #else
+ typedef std::reverse_iterator<iterator, std::random_access_iterator_tag,
+ int, int&, int*, std::ptrdiff_t> reverse_iterator;
+
+ typedef std::reverse_iterator<const_iterator, std::random_access_iterator_tag,
+ int, const int&, const int*, std::ptrdiff_t> 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<const slot_base&>(slot_))); }
+
+ iterator insert(iterator i, slot_type&& slot_)
+ { return iterator(list_->insert(i.i_, std::move(static_cast<slot_base&>(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 <class T_emitter, class T_result = typename T_emitter::result_type>
+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<const slot_type&>(*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 <class T_emitter>
+struct slot_iterator_buf<T_emitter, void>
+{
+ 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<const slot_type&>(*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 <class T_emitter, class T_result = typename T_emitter::result_type>
+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
+ {
+ auto __tmp(i_);
+ --__tmp;
+ if (!__tmp->empty() && !__tmp->blocked() && !invoked_)
+ {
+ r_ = (*c_)(static_cast<const slot_type&>(*__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 <class T_emitter>
+struct slot_reverse_iterator_buf<T_emitter, void>
+{
+ 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
+ {
+ auto __tmp(i_);
+ --__tmp;
+ if (!__tmp->empty() && !__tmp->blocked() && !invoked_)
+ {
+ (*c_)(static_cast<const slot_type&>(*__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_;
+};
+
+/** Abstracts signal emission.
+ * This template implements the emit() function of signal0.
+ * 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 <class T_return, class T_accumulator>
+struct signal_emit0
+{
+ typedef signal_emit0<T_return, T_accumulator> self_type;
+ typedef typename T_accumulator::result_type result_type;
+ typedef slot<T_return()> slot_type;
+ typedef internal::slot_iterator_buf<self_type, T_return> slot_iterator_buf_type;
+ typedef internal::slot_reverse_iterator_buf<self_type, T_return> slot_reverse_iterator_buf_type;
+ typedef signal_impl::const_iterator_type iterator_type;
+
+ signal_emit0() {}
+
+ /** Invokes a slot.
+ * @param _A_slot Some slot to invoke.
+ * @return The slot's return value.
+ */
+ T_return operator()(const slot_type& _A_slot) const
+ { return (sigc::internal::function_pointer_cast<typename slot_type::call_type>(_A_slot.rep_->call_))(_A_slot.rep_); }
+
+ /** Executes a list of slots using an accumulator of type @e T_accumulator.
+
+ * @return The accumulated return values of the slot invocations as processed by the accumulator.
+ */
+ static result_type emit(signal_impl* impl)
+ {
+ 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 ;
+ return accumulator(slot_iterator_buf_type(slots.begin(), &self),
+ slot_iterator_buf_type(slots.end(), &self));
+ }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
+
+ * @return The accumulated return values of the slot invocations as processed by the accumulator.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ static result_type emit_reverse(signal_impl* impl)
+ {
+ 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 ;
+ return accumulator(slot_reverse_iterator_buf_type(slots.end(), &self),
+ slot_reverse_iterator_buf_type(slots.begin(), &self));
+ }
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+
+};
+
+/** Abstracts signal emission.
+ * This template specialization implements an optimized emit()
+ * function for the case that no accumulator is used.
+ */
+template <class T_return>
+struct signal_emit0<T_return, nil>
+{
+ typedef signal_emit0<T_return, nil > self_type;
+ typedef T_return result_type;
+ typedef slot<T_return()> 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.
+ * 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.
+ * @return The return value of the last slot invoked.
+ */
+ static result_type emit(signal_impl* impl)
+ {
+ 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_);
+ auto 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_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_);
+ for (++it; it != slots.end(); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_);
+ }
+ }
+
+ return r_;
+ }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
+ * 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.
+ * @return The return value of the last slot invoked.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ static result_type emit_reverse(signal_impl* impl)
+ {
+ 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<signal_impl::iterator_type> reverse_iterator_type;
+#else
+ typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
+ slot_base, slot_base&, slot_base*, std::ptrdiff_t> 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_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_);
+ for (++it; it != reverse_iterator_type(slots.begin()); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_);
+ }
+ }
+
+ return r_;
+ }
+#endif // SIGCXX_DISABLE_DEPRECATED
+};
+
+/** 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_emit0<void, nil>
+{
+ typedef signal_emit0<void, nil> self_type;
+ typedef void result_type;
+ typedef slot<void()> slot_type;
+ typedef signal_impl::const_iterator_type iterator_type;
+ typedef void (*call_type)(slot_rep*);
+
+ /** Executes a list of slots using an accumulator of type @e T_accumulator.
+ * @param first An iterator pointing to the first slot in the list.
+ * @param last An iterator pointing to the last slot in the list.
+ */
+ static result_type emit(signal_impl* impl)
+ {
+ if (!impl || impl->slots_.empty()) return;
+ signal_exec exec(impl);
+ temp_slot_list slots(impl->slots_);
+
+ for (const auto& slot : slots)
+ {
+ if (slot.empty() || slot.blocked())
+ continue;
+ (sigc::internal::function_pointer_cast<call_type>(slot.rep_->call_))(slot.rep_);
+ }
+ }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
+ * @param first An iterator pointing to the first slot in the list.
+ * @param last An iterator pointing to the last slot in the list.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ static result_type emit_reverse(signal_impl* impl)
+ {
+ 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<signal_impl::iterator_type> reverse_iterator_type;
+#else
+ typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
+ slot_base, slot_base&, slot_base*, std::ptrdiff_t> reverse_iterator_type;
+#endif
+ for (auto it = reverse_iterator_type(slots.end()); it != reverse_iterator_type(slots.begin()); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_);
+ }
+ }
+#endif // SIGCXX_DISABLE_DEPRECATED
+};
+
+/** Abstracts signal emission.
+ * This template implements the emit() function of signal1.
+ * 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 <class T_return, class T_arg1, class T_accumulator>
+struct signal_emit1
+{
+ typedef signal_emit1<T_return, T_arg1, T_accumulator> self_type;
+ typedef typename T_accumulator::result_type result_type;
+ typedef slot<T_return(T_arg1)> slot_type;
+ typedef internal::slot_iterator_buf<self_type, T_return> slot_iterator_buf_type;
+ typedef internal::slot_reverse_iterator_buf<self_type, T_return> slot_reverse_iterator_buf_type;
+ typedef signal_impl::const_iterator_type iterator_type;
+
+ /** Instantiates the class.
+ * The parameters are stored in member variables. operator()() passes
+ * the values on to some slot.
+ */
+ signal_emit1(type_trait_take_t<T_arg1> _A_a1)
+ : _A_a1_(_A_a1) {}
+
+
+ /** 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 (sigc::internal::function_pointer_cast<typename slot_type::call_type>(_A_slot.rep_->call_))(_A_slot.rep_, _A_a1_); }
+
+ /** Executes a list of slots using an accumulator of type @e T_accumulator.
+ * The arguments are buffered in a temporary instance of signal_emit1.
+
+ * @param _A_a1 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(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1)
+ {
+ 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 (_A_a1);
+ return accumulator(slot_iterator_buf_type(slots.begin(), &self),
+ slot_iterator_buf_type(slots.end(), &self));
+ }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
+ * The arguments are buffered in a temporary instance of signal_emit1.
+
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @return The accumulated return values of the slot invocations as processed by the accumulator.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1)
+ {
+ 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 (_A_a1);
+ return accumulator(slot_reverse_iterator_buf_type(slots.end(), &self),
+ slot_reverse_iterator_buf_type(slots.begin(), &self));
+ }
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+
+ type_trait_take_t<T_arg1> _A_a1_;
+};
+
+/** Abstracts signal emission.
+ * This template specialization implements an optimized emit()
+ * function for the case that no accumulator is used.
+ */
+template <class T_return, class T_arg1>
+struct signal_emit1<T_return, T_arg1, nil>
+{
+ typedef signal_emit1<T_return, T_arg1, nil > self_type;
+ typedef T_return result_type;
+ typedef slot<T_return(T_arg1)> 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.
+ * 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_a1 Argument to be passed on to the slots.
+ * @return The return value of the last slot invoked.
+ */
+ static result_type emit(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1)
+ {
+ 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_);
+ auto 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_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1);
+ for (++it; it != slots.end(); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1);
+ }
+ }
+
+ return r_;
+ }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
+ * 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_a1 Argument to be passed on to the slots.
+ * @return The return value of the last slot invoked.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1)
+ {
+ 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<signal_impl::iterator_type> reverse_iterator_type;
+#else
+ typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
+ slot_base, slot_base&, slot_base*, std::ptrdiff_t> 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_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1);
+ for (++it; it != reverse_iterator_type(slots.begin()); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1);
+ }
+ }
+
+ return r_;
+ }
+#endif // SIGCXX_DISABLE_DEPRECATED
+};
+
+/** 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 <class T_arg1>
+struct signal_emit1<void, T_arg1, nil>
+{
+ typedef signal_emit1<void, T_arg1, nil> self_type;
+ typedef void result_type;
+ typedef slot<void(T_arg1)> 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.
+ * 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.
+ * @param _A_a1 Argument to be passed on to the slots.
+ */
+ static result_type emit(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1)
+ {
+ if (!impl || impl->slots_.empty()) return;
+ signal_exec exec(impl);
+ temp_slot_list slots(impl->slots_);
+
+ for (const auto& slot : slots)
+ {
+ if (slot.empty() || slot.blocked())
+ continue;
+ (sigc::internal::function_pointer_cast<call_type>(slot.rep_->call_))(slot.rep_, _A_a1);
+ }
+ }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
+ * 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.
+ * @param _A_a1 Argument to be passed on to the slots.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1)
+ {
+ 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<signal_impl::iterator_type> reverse_iterator_type;
+#else
+ typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
+ slot_base, slot_base&, slot_base*, std::ptrdiff_t> reverse_iterator_type;
+#endif
+ for (auto it = reverse_iterator_type(slots.end()); it != reverse_iterator_type(slots.begin()); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1);
+ }
+ }
+#endif // SIGCXX_DISABLE_DEPRECATED
+};
+
+/** Abstracts signal emission.
+ * This template implements the emit() function of signal2.
+ * 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 <class T_return, class T_arg1, class T_arg2, class T_accumulator>
+struct signal_emit2
+{
+ typedef signal_emit2<T_return, T_arg1, T_arg2, T_accumulator> self_type;
+ typedef typename T_accumulator::result_type result_type;
+ typedef slot<T_return(T_arg1, T_arg2)> slot_type;
+ typedef internal::slot_iterator_buf<self_type, T_return> slot_iterator_buf_type;
+ typedef internal::slot_reverse_iterator_buf<self_type, T_return> slot_reverse_iterator_buf_type;
+ typedef signal_impl::const_iterator_type iterator_type;
+
+ /** Instantiates the class.
+ * The parameters are stored in member variables. operator()() passes
+ * the values on to some slot.
+ */
+ signal_emit2(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2)
+ : _A_a1_(_A_a1), _A_a2_(_A_a2) {}
+
+
+ /** 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 (sigc::internal::function_pointer_cast<typename slot_type::call_type>(_A_slot.rep_->call_))(_A_slot.rep_, _A_a1_, _A_a2_); }
+
+ /** Executes a list of slots using an accumulator of type @e T_accumulator.
+ * The arguments are buffered in a temporary instance of signal_emit2.
+
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 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(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2)
+ {
+ 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 (_A_a1, _A_a2);
+ return accumulator(slot_iterator_buf_type(slots.begin(), &self),
+ slot_iterator_buf_type(slots.end(), &self));
+ }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
+ * The arguments are buffered in a temporary instance of signal_emit2.
+
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @return The accumulated return values of the slot invocations as processed by the accumulator.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2)
+ {
+ 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 (_A_a1, _A_a2);
+ return accumulator(slot_reverse_iterator_buf_type(slots.end(), &self),
+ slot_reverse_iterator_buf_type(slots.begin(), &self));
+ }
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+
+ type_trait_take_t<T_arg1> _A_a1_;
+ type_trait_take_t<T_arg2> _A_a2_;
+};
+
+/** Abstracts signal emission.
+ * This template specialization implements an optimized emit()
+ * function for the case that no accumulator is used.
+ */
+template <class T_return, class T_arg1, class T_arg2>
+struct signal_emit2<T_return, T_arg1, T_arg2, nil>
+{
+ typedef signal_emit2<T_return, T_arg1, T_arg2, nil > self_type;
+ typedef T_return result_type;
+ typedef slot<T_return(T_arg1, T_arg2)> 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.
+ * 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_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @return The return value of the last slot invoked.
+ */
+ static result_type emit(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2)
+ {
+ 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_);
+ auto 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_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2);
+ for (++it; it != slots.end(); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2);
+ }
+ }
+
+ return r_;
+ }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
+ * 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_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @return The return value of the last slot invoked.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2)
+ {
+ 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<signal_impl::iterator_type> reverse_iterator_type;
+#else
+ typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
+ slot_base, slot_base&, slot_base*, std::ptrdiff_t> 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_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2);
+ for (++it; it != reverse_iterator_type(slots.begin()); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2);
+ }
+ }
+
+ return r_;
+ }
+#endif // SIGCXX_DISABLE_DEPRECATED
+};
+
+/** 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 <class T_arg1, class T_arg2>
+struct signal_emit2<void, T_arg1, T_arg2, nil>
+{
+ typedef signal_emit2<void, T_arg1, T_arg2, nil> self_type;
+ typedef void result_type;
+ typedef slot<void(T_arg1, T_arg2)> 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.
+ * 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.
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ */
+ static result_type emit(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2)
+ {
+ if (!impl || impl->slots_.empty()) return;
+ signal_exec exec(impl);
+ temp_slot_list slots(impl->slots_);
+
+ for (const auto& slot : slots)
+ {
+ if (slot.empty() || slot.blocked())
+ continue;
+ (sigc::internal::function_pointer_cast<call_type>(slot.rep_->call_))(slot.rep_, _A_a1, _A_a2);
+ }
+ }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
+ * 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.
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2)
+ {
+ 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<signal_impl::iterator_type> reverse_iterator_type;
+#else
+ typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
+ slot_base, slot_base&, slot_base*, std::ptrdiff_t> reverse_iterator_type;
+#endif
+ for (auto it = reverse_iterator_type(slots.end()); it != reverse_iterator_type(slots.begin()); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2);
+ }
+ }
+#endif // SIGCXX_DISABLE_DEPRECATED
+};
+
+/** Abstracts signal emission.
+ * This template implements the emit() function of signal3.
+ * 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 <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_accumulator>
+struct signal_emit3
+{
+ typedef signal_emit3<T_return, T_arg1, T_arg2, T_arg3, T_accumulator> self_type;
+ typedef typename T_accumulator::result_type result_type;
+ typedef slot<T_return(T_arg1, T_arg2, T_arg3)> slot_type;
+ typedef internal::slot_iterator_buf<self_type, T_return> slot_iterator_buf_type;
+ typedef internal::slot_reverse_iterator_buf<self_type, T_return> slot_reverse_iterator_buf_type;
+ typedef signal_impl::const_iterator_type iterator_type;
+
+ /** Instantiates the class.
+ * The parameters are stored in member variables. operator()() passes
+ * the values on to some slot.
+ */
+ signal_emit3(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3)
+ : _A_a1_(_A_a1), _A_a2_(_A_a2), _A_a3_(_A_a3) {}
+
+
+ /** 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 (sigc::internal::function_pointer_cast<typename slot_type::call_type>(_A_slot.rep_->call_))(_A_slot.rep_, _A_a1_, _A_a2_, _A_a3_); }
+
+ /** Executes a list of slots using an accumulator of type @e T_accumulator.
+ * The arguments are buffered in a temporary instance of signal_emit3.
+
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 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(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3)
+ {
+ 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 (_A_a1, _A_a2, _A_a3);
+ return accumulator(slot_iterator_buf_type(slots.begin(), &self),
+ slot_iterator_buf_type(slots.end(), &self));
+ }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
+ * The arguments are buffered in a temporary instance of signal_emit3.
+
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @return The accumulated return values of the slot invocations as processed by the accumulator.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3)
+ {
+ 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 (_A_a1, _A_a2, _A_a3);
+ return accumulator(slot_reverse_iterator_buf_type(slots.end(), &self),
+ slot_reverse_iterator_buf_type(slots.begin(), &self));
+ }
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+
+ type_trait_take_t<T_arg1> _A_a1_;
+ type_trait_take_t<T_arg2> _A_a2_;
+ type_trait_take_t<T_arg3> _A_a3_;
+};
+
+/** Abstracts signal emission.
+ * This template specialization implements an optimized emit()
+ * function for the case that no accumulator is used.
+ */
+template <class T_return, class T_arg1, class T_arg2, class T_arg3>
+struct signal_emit3<T_return, T_arg1, T_arg2, T_arg3, nil>
+{
+ typedef signal_emit3<T_return, T_arg1, T_arg2, T_arg3, nil > self_type;
+ typedef T_return result_type;
+ typedef slot<T_return(T_arg1, T_arg2, T_arg3)> 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.
+ * 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_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @return The return value of the last slot invoked.
+ */
+ static result_type emit(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3)
+ {
+ 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_);
+ auto 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_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3);
+ for (++it; it != slots.end(); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3);
+ }
+ }
+
+ return r_;
+ }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
+ * 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_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @return The return value of the last slot invoked.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3)
+ {
+ 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<signal_impl::iterator_type> reverse_iterator_type;
+#else
+ typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
+ slot_base, slot_base&, slot_base*, std::ptrdiff_t> 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_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3);
+ for (++it; it != reverse_iterator_type(slots.begin()); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3);
+ }
+ }
+
+ return r_;
+ }
+#endif // SIGCXX_DISABLE_DEPRECATED
+};
+
+/** 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 <class T_arg1, class T_arg2, class T_arg3>
+struct signal_emit3<void, T_arg1, T_arg2, T_arg3, nil>
+{
+ typedef signal_emit3<void, T_arg1, T_arg2, T_arg3, nil> self_type;
+ typedef void result_type;
+ typedef slot<void(T_arg1, T_arg2, T_arg3)> 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.
+ * 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.
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ */
+ static result_type emit(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3)
+ {
+ if (!impl || impl->slots_.empty()) return;
+ signal_exec exec(impl);
+ temp_slot_list slots(impl->slots_);
+
+ for (const auto& slot : slots)
+ {
+ if (slot.empty() || slot.blocked())
+ continue;
+ (sigc::internal::function_pointer_cast<call_type>(slot.rep_->call_))(slot.rep_, _A_a1, _A_a2, _A_a3);
+ }
+ }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
+ * 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.
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3)
+ {
+ 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<signal_impl::iterator_type> reverse_iterator_type;
+#else
+ typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
+ slot_base, slot_base&, slot_base*, std::ptrdiff_t> reverse_iterator_type;
+#endif
+ for (auto it = reverse_iterator_type(slots.end()); it != reverse_iterator_type(slots.begin()); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3);
+ }
+ }
+#endif // SIGCXX_DISABLE_DEPRECATED
+};
+
+/** Abstracts signal emission.
+ * This template implements the emit() function of signal4.
+ * 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 <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_accumulator>
+struct signal_emit4
+{
+ typedef signal_emit4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator> self_type;
+ typedef typename T_accumulator::result_type result_type;
+ typedef slot<T_return(T_arg1, T_arg2, T_arg3, T_arg4)> slot_type;
+ typedef internal::slot_iterator_buf<self_type, T_return> slot_iterator_buf_type;
+ typedef internal::slot_reverse_iterator_buf<self_type, T_return> slot_reverse_iterator_buf_type;
+ typedef signal_impl::const_iterator_type iterator_type;
+
+ /** Instantiates the class.
+ * The parameters are stored in member variables. operator()() passes
+ * the values on to some slot.
+ */
+ signal_emit4(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4)
+ : _A_a1_(_A_a1), _A_a2_(_A_a2), _A_a3_(_A_a3), _A_a4_(_A_a4) {}
+
+
+ /** 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 (sigc::internal::function_pointer_cast<typename slot_type::call_type>(_A_slot.rep_->call_))(_A_slot.rep_, _A_a1_, _A_a2_, _A_a3_, _A_a4_); }
+
+ /** Executes a list of slots using an accumulator of type @e T_accumulator.
+ * The arguments are buffered in a temporary instance of signal_emit4.
+
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @param _A_a4 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(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4)
+ {
+ 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 (_A_a1, _A_a2, _A_a3, _A_a4);
+ return accumulator(slot_iterator_buf_type(slots.begin(), &self),
+ slot_iterator_buf_type(slots.end(), &self));
+ }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
+ * The arguments are buffered in a temporary instance of signal_emit4.
+
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @param _A_a4 Argument to be passed on to the slots.
+ * @return The accumulated return values of the slot invocations as processed by the accumulator.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4)
+ {
+ 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 (_A_a1, _A_a2, _A_a3, _A_a4);
+ return accumulator(slot_reverse_iterator_buf_type(slots.end(), &self),
+ slot_reverse_iterator_buf_type(slots.begin(), &self));
+ }
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+
+ type_trait_take_t<T_arg1> _A_a1_;
+ type_trait_take_t<T_arg2> _A_a2_;
+ type_trait_take_t<T_arg3> _A_a3_;
+ type_trait_take_t<T_arg4> _A_a4_;
+};
+
+/** Abstracts signal emission.
+ * This template specialization implements an optimized emit()
+ * function for the case that no accumulator is used.
+ */
+template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+struct signal_emit4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil>
+{
+ typedef signal_emit4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil > self_type;
+ typedef T_return result_type;
+ typedef slot<T_return(T_arg1, T_arg2, T_arg3, T_arg4)> 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.
+ * 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_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @param _A_a4 Argument to be passed on to the slots.
+ * @return The return value of the last slot invoked.
+ */
+ static result_type emit(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4)
+ {
+ 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_);
+ auto 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_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4);
+ for (++it; it != slots.end(); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4);
+ }
+ }
+
+ return r_;
+ }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
+ * 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_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @param _A_a4 Argument to be passed on to the slots.
+ * @return The return value of the last slot invoked.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4)
+ {
+ 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<signal_impl::iterator_type> reverse_iterator_type;
+#else
+ typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
+ slot_base, slot_base&, slot_base*, std::ptrdiff_t> 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_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4);
+ for (++it; it != reverse_iterator_type(slots.begin()); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4);
+ }
+ }
+
+ return r_;
+ }
+#endif // SIGCXX_DISABLE_DEPRECATED
+};
+
+/** 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+struct signal_emit4<void, T_arg1, T_arg2, T_arg3, T_arg4, nil>
+{
+ typedef signal_emit4<void, T_arg1, T_arg2, T_arg3, T_arg4, nil> self_type;
+ typedef void result_type;
+ typedef slot<void(T_arg1, T_arg2, T_arg3, T_arg4)> 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.
+ * 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.
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @param _A_a4 Argument to be passed on to the slots.
+ */
+ static result_type emit(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4)
+ {
+ if (!impl || impl->slots_.empty()) return;
+ signal_exec exec(impl);
+ temp_slot_list slots(impl->slots_);
+
+ for (const auto& slot : slots)
+ {
+ if (slot.empty() || slot.blocked())
+ continue;
+ (sigc::internal::function_pointer_cast<call_type>(slot.rep_->call_))(slot.rep_, _A_a1, _A_a2, _A_a3, _A_a4);
+ }
+ }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
+ * 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.
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @param _A_a4 Argument to be passed on to the slots.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4)
+ {
+ 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<signal_impl::iterator_type> reverse_iterator_type;
+#else
+ typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
+ slot_base, slot_base&, slot_base*, std::ptrdiff_t> reverse_iterator_type;
+#endif
+ for (auto it = reverse_iterator_type(slots.end()); it != reverse_iterator_type(slots.begin()); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4);
+ }
+ }
+#endif // SIGCXX_DISABLE_DEPRECATED
+};
+
+/** Abstracts signal emission.
+ * This template implements the emit() function of signal5.
+ * 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 <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_accumulator>
+struct signal_emit5
+{
+ typedef signal_emit5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator> self_type;
+ typedef typename T_accumulator::result_type result_type;
+ typedef slot<T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)> slot_type;
+ typedef internal::slot_iterator_buf<self_type, T_return> slot_iterator_buf_type;
+ typedef internal::slot_reverse_iterator_buf<self_type, T_return> slot_reverse_iterator_buf_type;
+ typedef signal_impl::const_iterator_type iterator_type;
+
+ /** Instantiates the class.
+ * The parameters are stored in member variables. operator()() passes
+ * the values on to some slot.
+ */
+ signal_emit5(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5)
+ : _A_a1_(_A_a1), _A_a2_(_A_a2), _A_a3_(_A_a3), _A_a4_(_A_a4), _A_a5_(_A_a5) {}
+
+
+ /** 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 (sigc::internal::function_pointer_cast<typename slot_type::call_type>(_A_slot.rep_->call_))(_A_slot.rep_, _A_a1_, _A_a2_, _A_a3_, _A_a4_, _A_a5_); }
+
+ /** Executes a list of slots using an accumulator of type @e T_accumulator.
+ * The arguments are buffered in a temporary instance of signal_emit5.
+
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @param _A_a4 Argument to be passed on to the slots.
+ * @param _A_a5 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(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5)
+ {
+ 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 (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5);
+ return accumulator(slot_iterator_buf_type(slots.begin(), &self),
+ slot_iterator_buf_type(slots.end(), &self));
+ }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
+ * The arguments are buffered in a temporary instance of signal_emit5.
+
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @param _A_a4 Argument to be passed on to the slots.
+ * @param _A_a5 Argument to be passed on to the slots.
+ * @return The accumulated return values of the slot invocations as processed by the accumulator.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5)
+ {
+ 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 (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5);
+ return accumulator(slot_reverse_iterator_buf_type(slots.end(), &self),
+ slot_reverse_iterator_buf_type(slots.begin(), &self));
+ }
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+
+ type_trait_take_t<T_arg1> _A_a1_;
+ type_trait_take_t<T_arg2> _A_a2_;
+ type_trait_take_t<T_arg3> _A_a3_;
+ type_trait_take_t<T_arg4> _A_a4_;
+ type_trait_take_t<T_arg5> _A_a5_;
+};
+
+/** Abstracts signal emission.
+ * This template specialization implements an optimized emit()
+ * function for the case that no accumulator is used.
+ */
+template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+struct signal_emit5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil>
+{
+ typedef signal_emit5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil > self_type;
+ typedef T_return result_type;
+ typedef slot<T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)> 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.
+ * 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_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @param _A_a4 Argument to be passed on to the slots.
+ * @param _A_a5 Argument to be passed on to the slots.
+ * @return The return value of the last slot invoked.
+ */
+ static result_type emit(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5)
+ {
+ 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_);
+ auto 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_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5);
+ for (++it; it != slots.end(); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5);
+ }
+ }
+
+ return r_;
+ }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
+ * 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_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @param _A_a4 Argument to be passed on to the slots.
+ * @param _A_a5 Argument to be passed on to the slots.
+ * @return The return value of the last slot invoked.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5)
+ {
+ 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<signal_impl::iterator_type> reverse_iterator_type;
+#else
+ typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
+ slot_base, slot_base&, slot_base*, std::ptrdiff_t> 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_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5);
+ for (++it; it != reverse_iterator_type(slots.begin()); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5);
+ }
+ }
+
+ return r_;
+ }
+#endif // SIGCXX_DISABLE_DEPRECATED
+};
+
+/** 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+struct signal_emit5<void, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil>
+{
+ typedef signal_emit5<void, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil> self_type;
+ typedef void result_type;
+ typedef slot<void(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)> 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.
+ * 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.
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @param _A_a4 Argument to be passed on to the slots.
+ * @param _A_a5 Argument to be passed on to the slots.
+ */
+ static result_type emit(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5)
+ {
+ if (!impl || impl->slots_.empty()) return;
+ signal_exec exec(impl);
+ temp_slot_list slots(impl->slots_);
+
+ for (const auto& slot : slots)
+ {
+ if (slot.empty() || slot.blocked())
+ continue;
+ (sigc::internal::function_pointer_cast<call_type>(slot.rep_->call_))(slot.rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5);
+ }
+ }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
+ * 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.
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @param _A_a4 Argument to be passed on to the slots.
+ * @param _A_a5 Argument to be passed on to the slots.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5)
+ {
+ 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<signal_impl::iterator_type> reverse_iterator_type;
+#else
+ typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
+ slot_base, slot_base&, slot_base*, std::ptrdiff_t> reverse_iterator_type;
+#endif
+ for (auto it = reverse_iterator_type(slots.end()); it != reverse_iterator_type(slots.begin()); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5);
+ }
+ }
+#endif // SIGCXX_DISABLE_DEPRECATED
+};
+
+/** Abstracts signal emission.
+ * This template implements the emit() function of signal6.
+ * 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 <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_accumulator>
+struct signal_emit6
+{
+ typedef signal_emit6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator> self_type;
+ typedef typename T_accumulator::result_type result_type;
+ typedef slot<T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)> slot_type;
+ typedef internal::slot_iterator_buf<self_type, T_return> slot_iterator_buf_type;
+ typedef internal::slot_reverse_iterator_buf<self_type, T_return> slot_reverse_iterator_buf_type;
+ typedef signal_impl::const_iterator_type iterator_type;
+
+ /** Instantiates the class.
+ * The parameters are stored in member variables. operator()() passes
+ * the values on to some slot.
+ */
+ signal_emit6(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6)
+ : _A_a1_(_A_a1), _A_a2_(_A_a2), _A_a3_(_A_a3), _A_a4_(_A_a4), _A_a5_(_A_a5), _A_a6_(_A_a6) {}
+
+
+ /** 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 (sigc::internal::function_pointer_cast<typename slot_type::call_type>(_A_slot.rep_->call_))(_A_slot.rep_, _A_a1_, _A_a2_, _A_a3_, _A_a4_, _A_a5_, _A_a6_); }
+
+ /** Executes a list of slots using an accumulator of type @e T_accumulator.
+ * The arguments are buffered in a temporary instance of signal_emit6.
+
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @param _A_a4 Argument to be passed on to the slots.
+ * @param _A_a5 Argument to be passed on to the slots.
+ * @param _A_a6 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(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6)
+ {
+ 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 (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6);
+ return accumulator(slot_iterator_buf_type(slots.begin(), &self),
+ slot_iterator_buf_type(slots.end(), &self));
+ }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
+ * The arguments are buffered in a temporary instance of signal_emit6.
+
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @param _A_a4 Argument to be passed on to the slots.
+ * @param _A_a5 Argument to be passed on to the slots.
+ * @param _A_a6 Argument to be passed on to the slots.
+ * @return The accumulated return values of the slot invocations as processed by the accumulator.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6)
+ {
+ 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 (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6);
+ return accumulator(slot_reverse_iterator_buf_type(slots.end(), &self),
+ slot_reverse_iterator_buf_type(slots.begin(), &self));
+ }
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+
+ type_trait_take_t<T_arg1> _A_a1_;
+ type_trait_take_t<T_arg2> _A_a2_;
+ type_trait_take_t<T_arg3> _A_a3_;
+ type_trait_take_t<T_arg4> _A_a4_;
+ type_trait_take_t<T_arg5> _A_a5_;
+ type_trait_take_t<T_arg6> _A_a6_;
+};
+
+/** Abstracts signal emission.
+ * This template specialization implements an optimized emit()
+ * function for the case that no accumulator is used.
+ */
+template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+struct signal_emit6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>
+{
+ typedef signal_emit6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil > self_type;
+ typedef T_return result_type;
+ typedef slot<T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)> 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.
+ * 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_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @param _A_a4 Argument to be passed on to the slots.
+ * @param _A_a5 Argument to be passed on to the slots.
+ * @param _A_a6 Argument to be passed on to the slots.
+ * @return The return value of the last slot invoked.
+ */
+ static result_type emit(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6)
+ {
+ 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_);
+ auto 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_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6);
+ for (++it; it != slots.end(); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6);
+ }
+ }
+
+ return r_;
+ }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
+ * 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_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @param _A_a4 Argument to be passed on to the slots.
+ * @param _A_a5 Argument to be passed on to the slots.
+ * @param _A_a6 Argument to be passed on to the slots.
+ * @return The return value of the last slot invoked.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6)
+ {
+ 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<signal_impl::iterator_type> reverse_iterator_type;
+#else
+ typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
+ slot_base, slot_base&, slot_base*, std::ptrdiff_t> 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_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6);
+ for (++it; it != reverse_iterator_type(slots.begin()); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6);
+ }
+ }
+
+ return r_;
+ }
+#endif // SIGCXX_DISABLE_DEPRECATED
+};
+
+/** 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+struct signal_emit6<void, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>
+{
+ typedef signal_emit6<void, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil> self_type;
+ typedef void result_type;
+ typedef slot<void(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)> 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.
+ * 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.
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @param _A_a4 Argument to be passed on to the slots.
+ * @param _A_a5 Argument to be passed on to the slots.
+ * @param _A_a6 Argument to be passed on to the slots.
+ */
+ static result_type emit(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6)
+ {
+ if (!impl || impl->slots_.empty()) return;
+ signal_exec exec(impl);
+ temp_slot_list slots(impl->slots_);
+
+ for (const auto& slot : slots)
+ {
+ if (slot.empty() || slot.blocked())
+ continue;
+ (sigc::internal::function_pointer_cast<call_type>(slot.rep_->call_))(slot.rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6);
+ }
+ }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
+ * 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.
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @param _A_a4 Argument to be passed on to the slots.
+ * @param _A_a5 Argument to be passed on to the slots.
+ * @param _A_a6 Argument to be passed on to the slots.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6)
+ {
+ 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<signal_impl::iterator_type> reverse_iterator_type;
+#else
+ typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
+ slot_base, slot_base&, slot_base*, std::ptrdiff_t> reverse_iterator_type;
+#endif
+ for (auto it = reverse_iterator_type(slots.end()); it != reverse_iterator_type(slots.begin()); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6);
+ }
+ }
+#endif // SIGCXX_DISABLE_DEPRECATED
+};
+
+/** Abstracts signal emission.
+ * This template implements the emit() function of signal7.
+ * 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 <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_accumulator>
+struct signal_emit7
+{
+ typedef signal_emit7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator> self_type;
+ typedef typename T_accumulator::result_type result_type;
+ typedef slot<T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)> slot_type;
+ typedef internal::slot_iterator_buf<self_type, T_return> slot_iterator_buf_type;
+ typedef internal::slot_reverse_iterator_buf<self_type, T_return> slot_reverse_iterator_buf_type;
+ typedef signal_impl::const_iterator_type iterator_type;
+
+ /** Instantiates the class.
+ * The parameters are stored in member variables. operator()() passes
+ * the values on to some slot.
+ */
+ signal_emit7(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7)
+ : _A_a1_(_A_a1), _A_a2_(_A_a2), _A_a3_(_A_a3), _A_a4_(_A_a4), _A_a5_(_A_a5), _A_a6_(_A_a6), _A_a7_(_A_a7) {}
+
+
+ /** 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 (sigc::internal::function_pointer_cast<typename slot_type::call_type>(_A_slot.rep_->call_))(_A_slot.rep_, _A_a1_, _A_a2_, _A_a3_, _A_a4_, _A_a5_, _A_a6_, _A_a7_); }
+
+ /** Executes a list of slots using an accumulator of type @e T_accumulator.
+ * The arguments are buffered in a temporary instance of signal_emit7.
+
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @param _A_a4 Argument to be passed on to the slots.
+ * @param _A_a5 Argument to be passed on to the slots.
+ * @param _A_a6 Argument to be passed on to the slots.
+ * @param _A_a7 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(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7)
+ {
+ 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 (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7);
+ return accumulator(slot_iterator_buf_type(slots.begin(), &self),
+ slot_iterator_buf_type(slots.end(), &self));
+ }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
+ * The arguments are buffered in a temporary instance of signal_emit7.
+
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @param _A_a4 Argument to be passed on to the slots.
+ * @param _A_a5 Argument to be passed on to the slots.
+ * @param _A_a6 Argument to be passed on to the slots.
+ * @param _A_a7 Argument to be passed on to the slots.
+ * @return The accumulated return values of the slot invocations as processed by the accumulator.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7)
+ {
+ 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 (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7);
+ return accumulator(slot_reverse_iterator_buf_type(slots.end(), &self),
+ slot_reverse_iterator_buf_type(slots.begin(), &self));
+ }
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+
+ type_trait_take_t<T_arg1> _A_a1_;
+ type_trait_take_t<T_arg2> _A_a2_;
+ type_trait_take_t<T_arg3> _A_a3_;
+ type_trait_take_t<T_arg4> _A_a4_;
+ type_trait_take_t<T_arg5> _A_a5_;
+ type_trait_take_t<T_arg6> _A_a6_;
+ type_trait_take_t<T_arg7> _A_a7_;
+};
+
+/** Abstracts signal emission.
+ * This template specialization implements an optimized emit()
+ * function for the case that no accumulator is used.
+ */
+template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+struct signal_emit7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil>
+{
+ typedef signal_emit7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil > self_type;
+ typedef T_return result_type;
+ typedef slot<T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)> 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.
+ * 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_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @param _A_a4 Argument to be passed on to the slots.
+ * @param _A_a5 Argument to be passed on to the slots.
+ * @param _A_a6 Argument to be passed on to the slots.
+ * @param _A_a7 Argument to be passed on to the slots.
+ * @return The return value of the last slot invoked.
+ */
+ static result_type emit(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7)
+ {
+ 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_);
+ auto 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_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7);
+ for (++it; it != slots.end(); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7);
+ }
+ }
+
+ return r_;
+ }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
+ * 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_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @param _A_a4 Argument to be passed on to the slots.
+ * @param _A_a5 Argument to be passed on to the slots.
+ * @param _A_a6 Argument to be passed on to the slots.
+ * @param _A_a7 Argument to be passed on to the slots.
+ * @return The return value of the last slot invoked.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7)
+ {
+ 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<signal_impl::iterator_type> reverse_iterator_type;
+#else
+ typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
+ slot_base, slot_base&, slot_base*, std::ptrdiff_t> 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_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7);
+ for (++it; it != reverse_iterator_type(slots.begin()); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7);
+ }
+ }
+
+ return r_;
+ }
+#endif // SIGCXX_DISABLE_DEPRECATED
+};
+
+/** 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 <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+struct signal_emit7<void, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil>
+{
+ typedef signal_emit7<void, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil> self_type;
+ typedef void result_type;
+ typedef slot<void(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)> 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.
+ * 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.
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @param _A_a4 Argument to be passed on to the slots.
+ * @param _A_a5 Argument to be passed on to the slots.
+ * @param _A_a6 Argument to be passed on to the slots.
+ * @param _A_a7 Argument to be passed on to the slots.
+ */
+ static result_type emit(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7)
+ {
+ if (!impl || impl->slots_.empty()) return;
+ signal_exec exec(impl);
+ temp_slot_list slots(impl->slots_);
+
+ for (const auto& slot : slots)
+ {
+ if (slot.empty() || slot.blocked())
+ continue;
+ (sigc::internal::function_pointer_cast<call_type>(slot.rep_->call_))(slot.rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7);
+ }
+ }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
+ * 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.
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @param _A_a4 Argument to be passed on to the slots.
+ * @param _A_a5 Argument to be passed on to the slots.
+ * @param _A_a6 Argument to be passed on to the slots.
+ * @param _A_a7 Argument to be passed on to the slots.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7)
+ {
+ 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<signal_impl::iterator_type> reverse_iterator_type;
+#else
+ typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
+ slot_base, slot_base&, slot_base*, std::ptrdiff_t> reverse_iterator_type;
+#endif
+ for (auto it = reverse_iterator_type(slots.end()); it != reverse_iterator_type(slots.begin()); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7);
+ }
+ }
+#endif // SIGCXX_DISABLE_DEPRECATED
+};
+
+
+} /* namespace internal */
+
+/** Signal declaration.
+ * signal0 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.
+ *
+ * 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_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 T_return, class T_accumulator=nil>
+class signal0
+ : public signal_base
+{
+public:
+ typedef internal::signal_emit0<T_return, T_accumulator> emitter_type;
+ typedef typename emitter_type::result_type result_type;
+ typedef slot<T_return()> slot_type;
+ typedef slot_list<slot_type> 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<const slot_base&>(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_base&>(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.
+ * @return The accumulated return values of the slot invocations.
+ */
+ result_type emit() const
+ { return emitter_type::emit(impl_); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Triggers the emission of the signal in reverse order (see emit()).
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ result_type emit_reverse() const
+ { return emitter_type::emit_reverse(impl_); }
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Triggers the emission of the signal (see emit()).
+ *
+ * @deprecated This is apparently not useful, but let us know if you need it.
+ */
+ result_type operator()() const
+ { return emit(); }
+
+ /** Creates a functor that calls emit() on this signal.
+ * @code
+ * sigc::mem_fun(mysignal, &sigc::signal0::emit)
+ * @endcode
+ * yields the same result.
+ * @return A functor that calls emit() on this signal.
+ */
+ bound_const_mem_functor0<result_type, signal0> make_slot() const
+ { return bound_const_mem_functor0<result_type, signal0>(*this, &signal0::emit); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** 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.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ 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.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ const slot_list_type slots() const
+ { return slot_list_type(const_cast<signal0*>(this)->impl()); }
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ signal0() {}
+
+ signal0(const signal0& src)
+ : signal_base(src) {}
+
+ signal0(signal0&& src)
+ : signal_base(std::move(src)) {}
+
+ signal0& operator=(const signal0& src)
+ {
+ signal_base::operator=(src);
+ return *this;
+ }
+
+ signal0& operator=(signal0&& src)
+ {
+ signal_base::operator=(std::move(src));
+ return *this;
+ }
+};
+
+/** Signal declaration.
+ * signal1 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.
+ *
+ * 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_arg1 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 T_return, class T_arg1, class T_accumulator=nil>
+class signal1
+ : public signal_base
+{
+public:
+ typedef internal::signal_emit1<T_return, T_arg1, T_accumulator> emitter_type;
+ typedef typename emitter_type::result_type result_type;
+ typedef slot<T_return(T_arg1)> slot_type;
+ typedef slot_list<slot_type> 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<const slot_base&>(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_base&>(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.
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @return The accumulated return values of the slot invocations.
+ */
+ result_type emit(type_trait_take_t<T_arg1> _A_a1) const
+ { return emitter_type::emit(impl_, _A_a1); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Triggers the emission of the signal in reverse order (see emit()).
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ result_type emit_reverse(type_trait_take_t<T_arg1> _A_a1) const
+ { return emitter_type::emit_reverse(impl_, _A_a1); }
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Triggers the emission of the signal (see emit()).
+ *
+ * @deprecated This is apparently not useful, but let us know if you need it.
+ */
+ result_type operator()(type_trait_take_t<T_arg1> _A_a1) const
+ { return emit(_A_a1); }
+
+ /** Creates a functor that calls emit() on this signal.
+ * @code
+ * sigc::mem_fun(mysignal, &sigc::signal1::emit)
+ * @endcode
+ * yields the same result.
+ * @return A functor that calls emit() on this signal.
+ */
+ bound_const_mem_functor1<result_type, signal1, type_trait_take_t<T_arg1>> make_slot() const
+ { return bound_const_mem_functor1<result_type, signal1, type_trait_take_t<T_arg1>>(*this, &signal1::emit); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** 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.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ 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.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ const slot_list_type slots() const
+ { return slot_list_type(const_cast<signal1*>(this)->impl()); }
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ signal1() {}
+
+ signal1(const signal1& src)
+ : signal_base(src) {}
+
+ signal1(signal1&& src)
+ : signal_base(std::move(src)) {}
+
+ signal1& operator=(const signal1& src)
+ {
+ signal_base::operator=(src);
+ return *this;
+ }
+
+ signal1& operator=(signal1&& src)
+ {
+ signal_base::operator=(std::move(src));
+ return *this;
+ }
+};
+
+/** Signal declaration.
+ * signal2 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.
+ *
+ * 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_arg1 Argument type used in the definition of emit().
+ * - @e T_arg2 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 T_return, class T_arg1, class T_arg2, class T_accumulator=nil>
+class signal2
+ : public signal_base
+{
+public:
+ typedef internal::signal_emit2<T_return, T_arg1, T_arg2, T_accumulator> emitter_type;
+ typedef typename emitter_type::result_type result_type;
+ typedef slot<T_return(T_arg1, T_arg2)> slot_type;
+ typedef slot_list<slot_type> 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<const slot_base&>(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_base&>(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.
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @return The accumulated return values of the slot invocations.
+ */
+ result_type emit(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
+ { return emitter_type::emit(impl_, _A_a1, _A_a2); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Triggers the emission of the signal in reverse order (see emit()).
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ result_type emit_reverse(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
+ { return emitter_type::emit_reverse(impl_, _A_a1, _A_a2); }
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Triggers the emission of the signal (see emit()).
+ *
+ * @deprecated This is apparently not useful, but let us know if you need it.
+ */
+ result_type operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
+ { return emit(_A_a1, _A_a2); }
+
+ /** Creates a functor that calls emit() on this signal.
+ * @code
+ * sigc::mem_fun(mysignal, &sigc::signal2::emit)
+ * @endcode
+ * yields the same result.
+ * @return A functor that calls emit() on this signal.
+ */
+ bound_const_mem_functor2<result_type, signal2, type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>> make_slot() const
+ { return bound_const_mem_functor2<result_type, signal2, type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>>(*this, &signal2::emit); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** 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.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ 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.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ const slot_list_type slots() const
+ { return slot_list_type(const_cast<signal2*>(this)->impl()); }
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ signal2() {}
+
+ signal2(const signal2& src)
+ : signal_base(src) {}
+
+ signal2(signal2&& src)
+ : signal_base(std::move(src)) {}
+
+ signal2& operator=(const signal2& src)
+ {
+ signal_base::operator=(src);
+ return *this;
+ }
+
+ signal2& operator=(signal2&& src)
+ {
+ signal_base::operator=(std::move(src));
+ return *this;
+ }
+};
+
+/** Signal declaration.
+ * signal3 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.
+ *
+ * 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_arg1 Argument type used in the definition of emit().
+ * - @e T_arg2 Argument type used in the definition of emit().
+ * - @e T_arg3 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 T_return, class T_arg1, class T_arg2, class T_arg3, class T_accumulator=nil>
+class signal3
+ : public signal_base
+{
+public:
+ typedef internal::signal_emit3<T_return, T_arg1, T_arg2, T_arg3, T_accumulator> emitter_type;
+ typedef typename emitter_type::result_type result_type;
+ typedef slot<T_return(T_arg1, T_arg2, T_arg3)> slot_type;
+ typedef slot_list<slot_type> 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<const slot_base&>(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_base&>(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.
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @return The accumulated return values of the slot invocations.
+ */
+ result_type emit(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
+ { return emitter_type::emit(impl_, _A_a1, _A_a2, _A_a3); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Triggers the emission of the signal in reverse order (see emit()).
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ result_type emit_reverse(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
+ { return emitter_type::emit_reverse(impl_, _A_a1, _A_a2, _A_a3); }
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Triggers the emission of the signal (see emit()).
+ *
+ * @deprecated This is apparently not useful, but let us know if you need it.
+ */
+ result_type operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
+ { return emit(_A_a1, _A_a2, _A_a3); }
+
+ /** Creates a functor that calls emit() on this signal.
+ * @code
+ * sigc::mem_fun(mysignal, &sigc::signal3::emit)
+ * @endcode
+ * yields the same result.
+ * @return A functor that calls emit() on this signal.
+ */
+ bound_const_mem_functor3<result_type, signal3, type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>, type_trait_take_t<T_arg3>> make_slot() const
+ { return bound_const_mem_functor3<result_type, signal3, type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>, type_trait_take_t<T_arg3>>(*this, &signal3::emit); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** 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.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ 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.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ const slot_list_type slots() const
+ { return slot_list_type(const_cast<signal3*>(this)->impl()); }
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ signal3() {}
+
+ signal3(const signal3& src)
+ : signal_base(src) {}
+
+ signal3(signal3&& src)
+ : signal_base(std::move(src)) {}
+
+ signal3& operator=(const signal3& src)
+ {
+ signal_base::operator=(src);
+ return *this;
+ }
+
+ signal3& operator=(signal3&& src)
+ {
+ signal_base::operator=(std::move(src));
+ return *this;
+ }
+};
+
+/** Signal declaration.
+ * signal4 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.
+ *
+ * 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_arg1 Argument type used in the definition of emit().
+ * - @e T_arg2 Argument type used in the definition of emit().
+ * - @e T_arg3 Argument type used in the definition of emit().
+ * - @e T_arg4 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 T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_accumulator=nil>
+class signal4
+ : public signal_base
+{
+public:
+ typedef internal::signal_emit4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator> emitter_type;
+ typedef typename emitter_type::result_type result_type;
+ typedef slot<T_return(T_arg1, T_arg2, T_arg3, T_arg4)> slot_type;
+ typedef slot_list<slot_type> 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<const slot_base&>(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_base&>(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.
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @param _A_a4 Argument to be passed on to the slots.
+ * @return The accumulated return values of the slot invocations.
+ */
+ result_type emit(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
+ { return emitter_type::emit(impl_, _A_a1, _A_a2, _A_a3, _A_a4); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Triggers the emission of the signal in reverse order (see emit()).
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ result_type emit_reverse(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
+ { return emitter_type::emit_reverse(impl_, _A_a1, _A_a2, _A_a3, _A_a4); }
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Triggers the emission of the signal (see emit()).
+ *
+ * @deprecated This is apparently not useful, but let us know if you need it.
+ */
+ result_type operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
+ { return emit(_A_a1, _A_a2, _A_a3, _A_a4); }
+
+ /** Creates a functor that calls emit() on this signal.
+ * @code
+ * sigc::mem_fun(mysignal, &sigc::signal4::emit)
+ * @endcode
+ * yields the same result.
+ * @return A functor that calls emit() on this signal.
+ */
+ bound_const_mem_functor4<result_type, signal4, type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>, type_trait_take_t<T_arg3>, type_trait_take_t<T_arg4>> make_slot() const
+ { return bound_const_mem_functor4<result_type, signal4, type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>, type_trait_take_t<T_arg3>, type_trait_take_t<T_arg4>>(*this, &signal4::emit); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** 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.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ 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.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ const slot_list_type slots() const
+ { return slot_list_type(const_cast<signal4*>(this)->impl()); }
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ signal4() {}
+
+ signal4(const signal4& src)
+ : signal_base(src) {}
+
+ signal4(signal4&& src)
+ : signal_base(std::move(src)) {}
+
+ signal4& operator=(const signal4& src)
+ {
+ signal_base::operator=(src);
+ return *this;
+ }
+
+ signal4& operator=(signal4&& src)
+ {
+ signal_base::operator=(std::move(src));
+ return *this;
+ }
+};
+
+/** Signal declaration.
+ * signal5 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.
+ *
+ * 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_arg1 Argument type used in the definition of emit().
+ * - @e T_arg2 Argument type used in the definition of emit().
+ * - @e T_arg3 Argument type used in the definition of emit().
+ * - @e T_arg4 Argument type used in the definition of emit().
+ * - @e T_arg5 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 T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_accumulator=nil>
+class signal5
+ : public signal_base
+{
+public:
+ typedef internal::signal_emit5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator> emitter_type;
+ typedef typename emitter_type::result_type result_type;
+ typedef slot<T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)> slot_type;
+ typedef slot_list<slot_type> 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<const slot_base&>(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_base&>(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.
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @param _A_a4 Argument to be passed on to the slots.
+ * @param _A_a5 Argument to be passed on to the slots.
+ * @return The accumulated return values of the slot invocations.
+ */
+ result_type emit(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
+ { return emitter_type::emit(impl_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Triggers the emission of the signal in reverse order (see emit()).
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ result_type emit_reverse(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
+ { return emitter_type::emit_reverse(impl_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Triggers the emission of the signal (see emit()).
+ *
+ * @deprecated This is apparently not useful, but let us know if you need it.
+ */
+ result_type operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
+ { return emit(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
+
+ /** Creates a functor that calls emit() on this signal.
+ * @code
+ * sigc::mem_fun(mysignal, &sigc::signal5::emit)
+ * @endcode
+ * yields the same result.
+ * @return A functor that calls emit() on this signal.
+ */
+ bound_const_mem_functor5<result_type, signal5, type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>, type_trait_take_t<T_arg3>, type_trait_take_t<T_arg4>, type_trait_take_t<T_arg5>> make_slot() const
+ { return bound_const_mem_functor5<result_type, signal5, type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>, type_trait_take_t<T_arg3>, type_trait_take_t<T_arg4>, type_trait_take_t<T_arg5>>(*this, &signal5::emit); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** 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.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ 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.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ const slot_list_type slots() const
+ { return slot_list_type(const_cast<signal5*>(this)->impl()); }
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ signal5() {}
+
+ signal5(const signal5& src)
+ : signal_base(src) {}
+
+ signal5(signal5&& src)
+ : signal_base(std::move(src)) {}
+
+ signal5& operator=(const signal5& src)
+ {
+ signal_base::operator=(src);
+ return *this;
+ }
+
+ signal5& operator=(signal5&& src)
+ {
+ signal_base::operator=(std::move(src));
+ return *this;
+ }
+};
+
+/** Signal declaration.
+ * signal6 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.
+ *
+ * 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_arg1 Argument type used in the definition of emit().
+ * - @e T_arg2 Argument type used in the definition of emit().
+ * - @e T_arg3 Argument type used in the definition of emit().
+ * - @e T_arg4 Argument type used in the definition of emit().
+ * - @e T_arg5 Argument type used in the definition of emit().
+ * - @e T_arg6 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 T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_accumulator=nil>
+class signal6
+ : public signal_base
+{
+public:
+ typedef internal::signal_emit6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator> emitter_type;
+ typedef typename emitter_type::result_type result_type;
+ typedef slot<T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)> slot_type;
+ typedef slot_list<slot_type> 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<const slot_base&>(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_base&>(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.
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @param _A_a4 Argument to be passed on to the slots.
+ * @param _A_a5 Argument to be passed on to the slots.
+ * @param _A_a6 Argument to be passed on to the slots.
+ * @return The accumulated return values of the slot invocations.
+ */
+ result_type emit(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
+ { return emitter_type::emit(impl_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Triggers the emission of the signal in reverse order (see emit()).
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ result_type emit_reverse(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
+ { return emitter_type::emit_reverse(impl_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Triggers the emission of the signal (see emit()).
+ *
+ * @deprecated This is apparently not useful, but let us know if you need it.
+ */
+ result_type operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
+ { return emit(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
+
+ /** Creates a functor that calls emit() on this signal.
+ * @code
+ * sigc::mem_fun(mysignal, &sigc::signal6::emit)
+ * @endcode
+ * yields the same result.
+ * @return A functor that calls emit() on this signal.
+ */
+ bound_const_mem_functor6<result_type, signal6, type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>, type_trait_take_t<T_arg3>, type_trait_take_t<T_arg4>, type_trait_take_t<T_arg5>, type_trait_take_t<T_arg6>> make_slot() const
+ { return bound_const_mem_functor6<result_type, signal6, type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>, type_trait_take_t<T_arg3>, type_trait_take_t<T_arg4>, type_trait_take_t<T_arg5>, type_trait_take_t<T_arg6>>(*this, &signal6::emit); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** 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.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ 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.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ const slot_list_type slots() const
+ { return slot_list_type(const_cast<signal6*>(this)->impl()); }
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ signal6() {}
+
+ signal6(const signal6& src)
+ : signal_base(src) {}
+
+ signal6(signal6&& src)
+ : signal_base(std::move(src)) {}
+
+ signal6& operator=(const signal6& src)
+ {
+ signal_base::operator=(src);
+ return *this;
+ }
+
+ signal6& operator=(signal6&& src)
+ {
+ signal_base::operator=(std::move(src));
+ return *this;
+ }
+};
+
+/** Signal declaration.
+ * signal7 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.
+ *
+ * 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_arg1 Argument type used in the definition of emit().
+ * - @e T_arg2 Argument type used in the definition of emit().
+ * - @e T_arg3 Argument type used in the definition of emit().
+ * - @e T_arg4 Argument type used in the definition of emit().
+ * - @e T_arg5 Argument type used in the definition of emit().
+ * - @e T_arg6 Argument type used in the definition of emit().
+ * - @e T_arg7 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 T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_accumulator=nil>
+class signal7
+ : public signal_base
+{
+public:
+ typedef internal::signal_emit7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator> emitter_type;
+ typedef typename emitter_type::result_type result_type;
+ typedef slot<T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)> slot_type;
+ typedef slot_list<slot_type> 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<const slot_base&>(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_base&>(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.
+ * @param _A_a1 Argument to be passed on to the slots.
+ * @param _A_a2 Argument to be passed on to the slots.
+ * @param _A_a3 Argument to be passed on to the slots.
+ * @param _A_a4 Argument to be passed on to the slots.
+ * @param _A_a5 Argument to be passed on to the slots.
+ * @param _A_a6 Argument to be passed on to the slots.
+ * @param _A_a7 Argument to be passed on to the slots.
+ * @return The accumulated return values of the slot invocations.
+ */
+ result_type emit(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
+ { return emitter_type::emit(impl_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** Triggers the emission of the signal in reverse order (see emit()).
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ result_type emit_reverse(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
+ { return emitter_type::emit_reverse(impl_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ /** Triggers the emission of the signal (see emit()).
+ *
+ * @deprecated This is apparently not useful, but let us know if you need it.
+ */
+ result_type operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
+ { return emit(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
+
+ /** Creates a functor that calls emit() on this signal.
+ * @code
+ * sigc::mem_fun(mysignal, &sigc::signal7::emit)
+ * @endcode
+ * yields the same result.
+ * @return A functor that calls emit() on this signal.
+ */
+ bound_const_mem_functor7<result_type, signal7, type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>, type_trait_take_t<T_arg3>, type_trait_take_t<T_arg4>, type_trait_take_t<T_arg5>, type_trait_take_t<T_arg6>, type_trait_take_t<T_arg7>> make_slot() const
+ { return bound_const_mem_functor7<result_type, signal7, type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>, type_trait_take_t<T_arg3>, type_trait_take_t<T_arg4>, type_trait_take_t<T_arg5>, type_trait_take_t<T_arg6>, type_trait_take_t<T_arg7>>(*this, &signal7::emit); }
+
+#ifndef SIGCXX_DISABLE_DEPRECATED
+ /** 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.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ 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.
+ *
+ * @deprecated This is apparently not useful, but please let us know if you need it.
+ */
+ const slot_list_type slots() const
+ { return slot_list_type(const_cast<signal7*>(this)->impl()); }
+#endif // SIGCXX_DISABLE_DEPRECATED
+
+ signal7() {}
+
+ signal7(const signal7& src)
+ : signal_base(src) {}
+
+ signal7(signal7&& src)
+ : signal_base(std::move(src)) {}
+
+ signal7& operator=(const signal7& src)
+ {
+ signal_base::operator=(src);
+ return *this;
+ }
+
+ signal7& operator=(signal7&& src)
+ {
+ signal_base::operator=(std::move(src));
+ return *this;
+ }
+};
+
+
+
+/** 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!
+ *
+ * The template arguments determine the function signature of
+ * the emit() function:
+ * - @e T_return The desired return type of the emit() function.
+ * - @e T_arg1 Argument type used in the definition of emit(). The default @p nil means no argument.
+ * - @e T_arg2 Argument type used in the definition of emit(). The default @p nil means no argument.
+ * - @e T_arg3 Argument type used in the definition of emit(). The default @p nil means no argument.
+ * - @e T_arg4 Argument type used in the definition of emit(). The default @p nil means no argument.
+ * - @e T_arg5 Argument type used in the definition of emit(). The default @p nil means no argument.
+ * - @e T_arg6 Argument type used in the definition of emit(). The default @p nil means no argument.
+ * - @e T_arg7 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<void, long> sig;
+ * sig.connect(sigc::ptr_fun(&foo));
+ * sig.emit(19);
+ * @endcode
+ *
+ * @deprecated Please use the syntax similar to that used by std::function<>:
+ * @code
+ * sigc::slot<void(bool, int)> some_slot;
+ * @endcode
+ *
+ * @ingroup signal
+ */
+template <class T_return, class T_arg1 = nil, class T_arg2 = nil, class T_arg3 = nil, class T_arg4 = nil, class T_arg5 = nil, class T_arg6 = nil, class T_arg7 = nil>
+class signal
+ : public signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil>
+{
+public:
+ /** 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<typename T_iterator>
+ * 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<typename T_iterator>
+ * result_type operator()(T_iterator first, T_iterator last) const
+ * {
+ * for (; first != last; ++first, ++n_)
+ * if (!*first) return false;
+ * return true;
+ * }
+ * };
+ * @endcode
+ *
+ * @ingroup signal
+ */
+ template <class T_accumulator>
+ class accumulated
+ : public signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator>
+ {
+ public:
+ accumulated() {}
+ accumulated(const accumulated& src)
+ : signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator>(src) {}
+ };
+
+ signal() {}
+
+ signal(const signal& src)
+ : signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil>(src) {}
+
+ signal(signal&& src)
+ : signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil>(std::move(src)) {}
+
+ signal& operator=(const signal& src)
+ {
+ signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil>::operator=(src);
+ return *this;
+ }
+
+ signal& operator=(signal&& src)
+ {
+ signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil>::operator=(std::move(src));
+ return *this;
+ }
+};
+
+/**
+ * This specialization allow use of the sigc::signal<R(Args...)> syntax,
+ */
+template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
+class signal<T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>
+ : public signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil>
+{
+public:
+ /** 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<typename T_iterator>
+ * 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<typename T_iterator>
+ * result_type operator()(T_iterator first, T_iterator last) const
+ * {
+ * for (; first != last; ++first, ++n_)
+ * if (!*first) return false;
+ * return true;
+ * }
+ * };
+ * @endcode
+ *
+ * @ingroup signal
+ */
+ template <class T_accumulator>
+ class accumulated
+ : public signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator>
+ {
+ public:
+ accumulated() {}
+ accumulated(const accumulated& src)
+ : signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator>(src) {}
+ };
+
+ signal() {}
+
+ signal(const signal& src)
+ : signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil>(src) {}
+
+ signal(signal&& src)
+ : signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil>(std::move(src)) {}
+
+ signal& operator=(const signal& src)
+ {
+ signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil>::operator=(src);
+ return *this;
+ }
+
+ signal& operator=(signal&& src)
+ {
+ signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil>::operator=(std::move(src));
+ return *this;
+ }
+};
+
+
+
+
+/** Convenience wrapper for the numbered sigc::signal0 template.
+ * See the base class for useful methods.
+ * This is the template specialization of the unnumbered sigc::signal
+ * template for 0 argument(s).
+ *
+ * @deprecated Please use the syntax similar to that used by std::function<>:
+ * @code
+ * sigc::slot<void(bool, int)> some_slot;
+ * @endcode
+ */
+template <class T_return>
+class signal <T_return, nil, nil, nil, nil, nil, nil, nil>
+ : public signal0<T_return, nil>
+{
+public:
+
+ /** Convenience wrapper for the numbered sigc::signal0 template.
+ * Like sigc::signal but the additional template parameter @e T_accumulator
+ * defines the accumulator type that should be used.
+ */
+ template <class T_accumulator>
+ class accumulated
+ : public signal0<T_return, T_accumulator>
+ {
+ public:
+ accumulated() {}
+ accumulated(const accumulated& src)
+ : signal0<T_return, T_accumulator>(src) {}
+ };
+
+ signal() {}
+
+ signal(const signal& src)
+ : signal0<T_return, nil>(src) {}
+
+ signal(signal&& src)
+ : signal0<T_return, nil>(std::move(src)) {}
+
+ signal& operator=(const signal& src)
+ {
+ signal0<T_return, nil>::operator=(src);
+ return *this;
+ }
+
+ signal& operator=(signal&& src)
+ {
+ signal0<T_return, nil>::operator=(std::move(src));
+ return *this;
+ }
+};
+
+/**
+ * This specialization allow use of the sigc::signal<R(Args...)> syntax,
+ */
+template <class T_return>
+class signal<T_return()>
+ : public signal0<T_return, nil>
+{
+public:
+
+ /** Convenience wrapper for the numbered sigc::signal0 template.
+ * Like sigc::signal but the additional template parameter @e T_accumulator
+ * defines the accumulator type that should be used.
+ */
+ template <class T_accumulator>
+ class accumulated
+ : public signal0<T_return, T_accumulator>
+ {
+ public:
+ accumulated() {}
+ accumulated(const accumulated& src)
+ : signal0<T_return, T_accumulator>(src) {}
+ };
+
+ signal() {}
+
+ signal(const signal& src)
+ : signal0<T_return, nil>(src) {}
+
+ signal(signal&& src)
+ : signal0<T_return, nil>(std::move(src)) {}
+
+ signal& operator=(const signal& src)
+ {
+ signal0<T_return, nil>::operator=(src);
+ return *this;
+ }
+
+ signal& operator=(signal&& src)
+ {
+ signal0<T_return, nil>::operator=(std::move(src));
+ return *this;
+ }
+};
+
+
+
+/** Convenience wrapper for the numbered sigc::signal1 template.
+ * See the base class for useful methods.
+ * This is the template specialization of the unnumbered sigc::signal
+ * template for 1 argument(s).
+ *
+ * @deprecated Please use the syntax similar to that used by std::function<>:
+ * @code
+ * sigc::slot<void(bool, int)> some_slot;
+ * @endcode
+ */
+template <class T_return, class T_arg1>
+class signal <T_return, T_arg1, nil, nil, nil, nil, nil, nil>
+ : public signal1<T_return, T_arg1, nil>
+{
+public:
+
+ /** Convenience wrapper for the numbered sigc::signal1 template.
+ * Like sigc::signal but the additional template parameter @e T_accumulator
+ * defines the accumulator type that should be used.
+ */
+ template <class T_accumulator>
+ class accumulated
+ : public signal1<T_return, T_arg1, T_accumulator>
+ {
+ public:
+ accumulated() {}
+ accumulated(const accumulated& src)
+ : signal1<T_return, T_arg1, T_accumulator>(src) {}
+ };
+
+ signal() {}
+
+ signal(const signal& src)
+ : signal1<T_return, T_arg1, nil>(src) {}
+
+ signal(signal&& src)
+ : signal1<T_return, T_arg1, nil>(std::move(src)) {}
+
+ signal& operator=(const signal& src)
+ {
+ signal1<T_return, T_arg1, nil>::operator=(src);
+ return *this;
+ }
+
+ signal& operator=(signal&& src)
+ {
+ signal1<T_return, T_arg1, nil>::operator=(std::move(src));
+ return *this;
+ }
+};
+
+/**
+ * This specialization allow use of the sigc::signal<R(Args...)> syntax,
+ */
+template <class T_return, class T_arg1>
+class signal<T_return(T_arg1)>
+ : public signal1<T_return, T_arg1, nil>
+{
+public:
+
+ /** Convenience wrapper for the numbered sigc::signal1 template.
+ * Like sigc::signal but the additional template parameter @e T_accumulator
+ * defines the accumulator type that should be used.
+ */
+ template <class T_accumulator>
+ class accumulated
+ : public signal1<T_return, T_arg1, T_accumulator>
+ {
+ public:
+ accumulated() {}
+ accumulated(const accumulated& src)
+ : signal1<T_return, T_arg1, T_accumulator>(src) {}
+ };
+
+ signal() {}
+
+ signal(const signal& src)
+ : signal1<T_return, T_arg1, nil>(src) {}
+
+ signal(signal&& src)
+ : signal1<T_return, T_arg1, nil>(std::move(src)) {}
+
+ signal& operator=(const signal& src)
+ {
+ signal1<T_return, T_arg1, nil>::operator=(src);
+ return *this;
+ }
+
+ signal& operator=(signal&& src)
+ {
+ signal1<T_return, T_arg1, nil>::operator=(std::move(src));
+ return *this;
+ }
+};
+
+
+
+/** Convenience wrapper for the numbered sigc::signal2 template.
+ * See the base class for useful methods.
+ * This is the template specialization of the unnumbered sigc::signal
+ * template for 2 argument(s).
+ *
+ * @deprecated Please use the syntax similar to that used by std::function<>:
+ * @code
+ * sigc::slot<void(bool, int)> some_slot;
+ * @endcode
+ */
+template <class T_return, class T_arg1, class T_arg2>
+class signal <T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil>
+ : public signal2<T_return, T_arg1, T_arg2, nil>
+{
+public:
+
+ /** Convenience wrapper for the numbered sigc::signal2 template.
+ * Like sigc::signal but the additional template parameter @e T_accumulator
+ * defines the accumulator type that should be used.
+ */
+ template <class T_accumulator>
+ class accumulated
+ : public signal2<T_return, T_arg1, T_arg2, T_accumulator>
+ {
+ public:
+ accumulated() {}
+ accumulated(const accumulated& src)
+ : signal2<T_return, T_arg1, T_arg2, T_accumulator>(src) {}
+ };
+
+ signal() {}
+
+ signal(const signal& src)
+ : signal2<T_return, T_arg1, T_arg2, nil>(src) {}
+
+ signal(signal&& src)
+ : signal2<T_return, T_arg1, T_arg2, nil>(std::move(src)) {}
+
+ signal& operator=(const signal& src)
+ {
+ signal2<T_return, T_arg1, T_arg2, nil>::operator=(src);
+ return *this;
+ }
+
+ signal& operator=(signal&& src)
+ {
+ signal2<T_return, T_arg1, T_arg2, nil>::operator=(std::move(src));
+ return *this;
+ }
+};
+
+/**
+ * This specialization allow use of the sigc::signal<R(Args...)> syntax,
+ */
+template <class T_return, class T_arg1, class T_arg2>
+class signal<T_return(T_arg1, T_arg2)>
+ : public signal2<T_return, T_arg1, T_arg2, nil>
+{
+public:
+
+ /** Convenience wrapper for the numbered sigc::signal2 template.
+ * Like sigc::signal but the additional template parameter @e T_accumulator
+ * defines the accumulator type that should be used.
+ */
+ template <class T_accumulator>
+ class accumulated
+ : public signal2<T_return, T_arg1, T_arg2, T_accumulator>
+ {
+ public:
+ accumulated() {}
+ accumulated(const accumulated& src)
+ : signal2<T_return, T_arg1, T_arg2, T_accumulator>(src) {}
+ };
+
+ signal() {}
+
+ signal(const signal& src)
+ : signal2<T_return, T_arg1, T_arg2, nil>(src) {}
+
+ signal(signal&& src)
+ : signal2<T_return, T_arg1, T_arg2, nil>(std::move(src)) {}
+
+ signal& operator=(const signal& src)
+ {
+ signal2<T_return, T_arg1, T_arg2, nil>::operator=(src);
+ return *this;
+ }
+
+ signal& operator=(signal&& src)
+ {
+ signal2<T_return, T_arg1, T_arg2, nil>::operator=(std::move(src));
+ return *this;
+ }
+};
+
+
+
+/** Convenience wrapper for the numbered sigc::signal3 template.
+ * See the base class for useful methods.
+ * This is the template specialization of the unnumbered sigc::signal
+ * template for 3 argument(s).
+ *
+ * @deprecated Please use the syntax similar to that used by std::function<>:
+ * @code
+ * sigc::slot<void(bool, int)> some_slot;
+ * @endcode
+ */
+template <class T_return, class T_arg1, class T_arg2, class T_arg3>
+class signal <T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil>
+ : public signal3<T_return, T_arg1, T_arg2, T_arg3, nil>
+{
+public:
+
+ /** Convenience wrapper for the numbered sigc::signal3 template.
+ * Like sigc::signal but the additional template parameter @e T_accumulator
+ * defines the accumulator type that should be used.
+ */
+ template <class T_accumulator>
+ class accumulated
+ : public signal3<T_return, T_arg1, T_arg2, T_arg3, T_accumulator>
+ {
+ public:
+ accumulated() {}
+ accumulated(const accumulated& src)
+ : signal3<T_return, T_arg1, T_arg2, T_arg3, T_accumulator>(src) {}
+ };
+
+ signal() {}
+
+ signal(const signal& src)
+ : signal3<T_return, T_arg1, T_arg2, T_arg3, nil>(src) {}
+
+ signal(signal&& src)
+ : signal3<T_return, T_arg1, T_arg2, T_arg3, nil>(std::move(src)) {}
+
+ signal& operator=(const signal& src)
+ {
+ signal3<T_return, T_arg1, T_arg2, T_arg3, nil>::operator=(src);
+ return *this;
+ }
+
+ signal& operator=(signal&& src)
+ {
+ signal3<T_return, T_arg1, T_arg2, T_arg3, nil>::operator=(std::move(src));
+ return *this;
+ }
+};
+
+/**
+ * This specialization allow use of the sigc::signal<R(Args...)> syntax,
+ */
+template <class T_return, class T_arg1, class T_arg2, class T_arg3>
+class signal<T_return(T_arg1, T_arg2, T_arg3)>
+ : public signal3<T_return, T_arg1, T_arg2, T_arg3, nil>
+{
+public:
+
+ /** Convenience wrapper for the numbered sigc::signal3 template.
+ * Like sigc::signal but the additional template parameter @e T_accumulator
+ * defines the accumulator type that should be used.
+ */
+ template <class T_accumulator>
+ class accumulated
+ : public signal3<T_return, T_arg1, T_arg2, T_arg3, T_accumulator>
+ {
+ public:
+ accumulated() {}
+ accumulated(const accumulated& src)
+ : signal3<T_return, T_arg1, T_arg2, T_arg3, T_accumulator>(src) {}
+ };
+
+ signal() {}
+
+ signal(const signal& src)
+ : signal3<T_return, T_arg1, T_arg2, T_arg3, nil>(src) {}
+
+ signal(signal&& src)
+ : signal3<T_return, T_arg1, T_arg2, T_arg3, nil>(std::move(src)) {}
+
+ signal& operator=(const signal& src)
+ {
+ signal3<T_return, T_arg1, T_arg2, T_arg3, nil>::operator=(src);
+ return *this;
+ }
+
+ signal& operator=(signal&& src)
+ {
+ signal3<T_return, T_arg1, T_arg2, T_arg3, nil>::operator=(std::move(src));
+ return *this;
+ }
+};
+
+
+
+/** Convenience wrapper for the numbered sigc::signal4 template.
+ * See the base class for useful methods.
+ * This is the template specialization of the unnumbered sigc::signal
+ * template for 4 argument(s).
+ *
+ * @deprecated Please use the syntax similar to that used by std::function<>:
+ * @code
+ * sigc::slot<void(bool, int)> some_slot;
+ * @endcode
+ */
+template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+class signal <T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil>
+ : public signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil>
+{
+public:
+
+ /** Convenience wrapper for the numbered sigc::signal4 template.
+ * Like sigc::signal but the additional template parameter @e T_accumulator
+ * defines the accumulator type that should be used.
+ */
+ template <class T_accumulator>
+ class accumulated
+ : public signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator>
+ {
+ public:
+ accumulated() {}
+ accumulated(const accumulated& src)
+ : signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator>(src) {}
+ };
+
+ signal() {}
+
+ signal(const signal& src)
+ : signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil>(src) {}
+
+ signal(signal&& src)
+ : signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil>(std::move(src)) {}
+
+ signal& operator=(const signal& src)
+ {
+ signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil>::operator=(src);
+ return *this;
+ }
+
+ signal& operator=(signal&& src)
+ {
+ signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil>::operator=(std::move(src));
+ return *this;
+ }
+};
+
+/**
+ * This specialization allow use of the sigc::signal<R(Args...)> syntax,
+ */
+template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
+class signal<T_return(T_arg1, T_arg2, T_arg3, T_arg4)>
+ : public signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil>
+{
+public:
+
+ /** Convenience wrapper for the numbered sigc::signal4 template.
+ * Like sigc::signal but the additional template parameter @e T_accumulator
+ * defines the accumulator type that should be used.
+ */
+ template <class T_accumulator>
+ class accumulated
+ : public signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator>
+ {
+ public:
+ accumulated() {}
+ accumulated(const accumulated& src)
+ : signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator>(src) {}
+ };
+
+ signal() {}
+
+ signal(const signal& src)
+ : signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil>(src) {}
+
+ signal(signal&& src)
+ : signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil>(std::move(src)) {}
+
+ signal& operator=(const signal& src)
+ {
+ signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil>::operator=(src);
+ return *this;
+ }
+
+ signal& operator=(signal&& src)
+ {
+ signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil>::operator=(std::move(src));
+ return *this;
+ }
+};
+
+
+
+/** Convenience wrapper for the numbered sigc::signal5 template.
+ * See the base class for useful methods.
+ * This is the template specialization of the unnumbered sigc::signal
+ * template for 5 argument(s).
+ *
+ * @deprecated Please use the syntax similar to that used by std::function<>:
+ * @code
+ * sigc::slot<void(bool, int)> some_slot;
+ * @endcode
+ */
+template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+class signal <T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil>
+ : public signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil>
+{
+public:
+
+ /** Convenience wrapper for the numbered sigc::signal5 template.
+ * Like sigc::signal but the additional template parameter @e T_accumulator
+ * defines the accumulator type that should be used.
+ */
+ template <class T_accumulator>
+ class accumulated
+ : public signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator>
+ {
+ public:
+ accumulated() {}
+ accumulated(const accumulated& src)
+ : signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator>(src) {}
+ };
+
+ signal() {}
+
+ signal(const signal& src)
+ : signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil>(src) {}
+
+ signal(signal&& src)
+ : signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil>(std::move(src)) {}
+
+ signal& operator=(const signal& src)
+ {
+ signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil>::operator=(src);
+ return *this;
+ }
+
+ signal& operator=(signal&& src)
+ {
+ signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil>::operator=(std::move(src));
+ return *this;
+ }
+};
+
+/**
+ * This specialization allow use of the sigc::signal<R(Args...)> syntax,
+ */
+template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
+class signal<T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>
+ : public signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil>
+{
+public:
+
+ /** Convenience wrapper for the numbered sigc::signal5 template.
+ * Like sigc::signal but the additional template parameter @e T_accumulator
+ * defines the accumulator type that should be used.
+ */
+ template <class T_accumulator>
+ class accumulated
+ : public signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator>
+ {
+ public:
+ accumulated() {}
+ accumulated(const accumulated& src)
+ : signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator>(src) {}
+ };
+
+ signal() {}
+
+ signal(const signal& src)
+ : signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil>(src) {}
+
+ signal(signal&& src)
+ : signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil>(std::move(src)) {}
+
+ signal& operator=(const signal& src)
+ {
+ signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil>::operator=(src);
+ return *this;
+ }
+
+ signal& operator=(signal&& src)
+ {
+ signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil>::operator=(std::move(src));
+ return *this;
+ }
+};
+
+
+
+/** Convenience wrapper for the numbered sigc::signal6 template.
+ * See the base class for useful methods.
+ * This is the template specialization of the unnumbered sigc::signal
+ * template for 6 argument(s).
+ *
+ * @deprecated Please use the syntax similar to that used by std::function<>:
+ * @code
+ * sigc::slot<void(bool, int)> some_slot;
+ * @endcode
+ */
+template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+class signal <T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>
+ : public signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>
+{
+public:
+
+ /** Convenience wrapper for the numbered sigc::signal6 template.
+ * Like sigc::signal but the additional template parameter @e T_accumulator
+ * defines the accumulator type that should be used.
+ */
+ template <class T_accumulator>
+ class accumulated
+ : public signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator>
+ {
+ public:
+ accumulated() {}
+ accumulated(const accumulated& src)
+ : signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator>(src) {}
+ };
+
+ signal() {}
+
+ signal(const signal& src)
+ : signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>(src) {}
+
+ signal(signal&& src)
+ : signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>(std::move(src)) {}
+
+ signal& operator=(const signal& src)
+ {
+ signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>::operator=(src);
+ return *this;
+ }
+
+ signal& operator=(signal&& src)
+ {
+ signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>::operator=(std::move(src));
+ return *this;
+ }
+};
+
+/**
+ * This specialization allow use of the sigc::signal<R(Args...)> syntax,
+ */
+template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
+class signal<T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>
+ : public signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>
+{
+public:
+
+ /** Convenience wrapper for the numbered sigc::signal6 template.
+ * Like sigc::signal but the additional template parameter @e T_accumulator
+ * defines the accumulator type that should be used.
+ */
+ template <class T_accumulator>
+ class accumulated
+ : public signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator>
+ {
+ public:
+ accumulated() {}
+ accumulated(const accumulated& src)
+ : signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator>(src) {}
+ };
+
+ signal() {}
+
+ signal(const signal& src)
+ : signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>(src) {}
+
+ signal(signal&& src)
+ : signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>(std::move(src)) {}
+
+ signal& operator=(const signal& src)
+ {
+ signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>::operator=(src);
+ return *this;
+ }
+
+ signal& operator=(signal&& src)
+ {
+ signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>::operator=(std::move(src));
+ return *this;
+ }
+};
+
+
+
+
+} /* namespace sigc */
+
+#ifdef SIGC_NIL_HAS_BEEN_PUSHED
+ #undef SIGC_NIL_HAS_BEEN_PUSHED
+ #pragma pop_macro("nil")
+#endif
+
+#endif /* _SIGC_SIGNAL_H_ */
projects / ext / sigc++-2.0.git / commitdiff
